STL 中專門用於排列的函式（可以處理存在重複資料集的排列問題）

標頭檔案：#include <algorithm>

using namespace std;

呼叫： next_permutation(start, end);

注意：函式要求輸入的是一個升序排列的序列的頭指標和尾指標.

用法：

// 陣列

int a[N];

sort(a, a+N);

next_permutation(a, a+N);

// 向量

vector<int> ivec;

sort(ivec.begin(), ivec.end());

next_permutation(ivec.begin(), ivec.end());

例子：

vector<int> myVec;

// 初始化程式碼

sort(myVec.begin(),myVec.end());

do{

for (i = 0 ;i < size;i ++ ) cout << myVec[i] << " \t " ;

cout << endl;

}while (next_permutation(myVec.begin(), myVec.end()));

ACM/ICPC 競賽之STL簡介

一、關於STL

STL(Standard Template Library，標準模板庫）是C++語言標準中的重

要組成部分。STL 以模板類和模板函式的形式為程式設計師提供了各種資料結構和

演算法的精巧實現，程式設計師如果能夠充分地利用STL，可以在程式碼空間、執行時

間和編碼效率上獲得極大的好處。

STL 大致可以分為三大類：演算法(algorithm)、容器(Container)、迭代器

(iterator)。

STL 容器是一些模板類，提供了多種組織資料的常用方法，例如vector(向量，

類似於陣列)、list(列表，類似於連結串列)、deque(雙向佇列)、set(集合)、

map(映象)、stack(棧)、queue(佇列)、priority_queue(優先佇列)等，

通過模板的引數我們可以指定容器中的元素型別。

STL 演算法是一些模板函式，提供了相當多的有用演算法和操作，從簡單如

for_each（遍歷）到複雜如stable_sort（穩定排序）。

STL 迭代器是對C 中的指標的一般化，用來將演算法和容器聯絡起來。幾乎所有

的STL 演算法都是通過迭代器來存取元素序列進行工作的，而STL 中的每一個

容器也都定義了其本身所專有的迭代器，用以存取容器中的元素。有趣的是，

普通的指標也可以像迭代器一樣工作。

熟悉了STL 後，你會發現，很多功能只需要用短短的幾行就可以實現了。通過

STL，我們可以構造出優雅而且高效的程式碼，甚至比你自己手工實現的程式碼效

果還要好。

STL 的另外一個特點是，它是以原始碼方式免費提供的，程式設計師不僅可以自由地

使用這些程式碼，也可以學習其原始碼，甚至按照自己的需要去修改它。

下面是用STL 寫的題Ugly Numbers 的程式碼：

#include <iostream>

#include <queue>

using namespace std;

typedef pair<unsigned long, int> node_type;

int main(){

unsigned long result[1500];

priority_queue< node_type, vector<node_type>,

greater<node_type> > Q;

Q.push( make_pair(1, 2) );

for (int i=0; i<1500; i++){

node_type node = Q.top(); Q.pop();

switch(node.second){

case 2: Q.push( make_pair(node.first*2, 2) );

case 3: Q.push( make_pair(node.first*3, 3) );

case 5: Q.push( make_pair(node.first*5, 5) );

}

result[i] = node.first;

}

int n;

cin >> n;

while (n>0){

cout << result[n-1] << endl;

cin >> n;

}

return 0;

}

在ACM 競賽中，熟練掌握和運用STL 對快速編寫實現程式碼會有極大的幫助。

二、使用STL

在C++標準中，STL 被組織為以下的一組標頭檔案（注意，是沒有.h 字尾的！）：

algorithm / deque / functional / iterator / list / map

memory / numeric / queue / set / stack / utility / vector

當我們需要使用STL 的某個功能時，需要嵌入相應的標頭檔案。但要注意的是，

在C++標準中，STL 是被定義在std 名稱空間中的。如下例所示：

#include <stack>

int main(){

std::stack<int> s;

s.push(0);

...

return 0;

}

如果希望在程式中直接引用STL，也可以在嵌入標頭檔案後，用using

namespace 語句將std 名稱空間匯入。如下例所示：

#include <stack>

using namespace std;

int main(){

stack<int> s;

s.push(0);

...

return 1;

}

STL 是C++語言機制運用的一個典範，通過學習STL 可以更深刻地理解C++

語言的思想和方法。在本系列的文章中不打算對STL 做深入的剖析，而只是想

介紹一些STL 的基本應用。

有興趣的同學，建議可以在有了一些STL 的使用經驗後，認真閱讀一下《C++

STL》這本書（電力出版社有該書的中文版）。

ACM/ICPC 競賽之STL--pair

STL 的<utility>標頭檔案中描述了一個看上去非常簡單的模板類pair，用來

表示一個二元組或元素對，並提供了按照字典序對元素對進行大小比較的比較

運算子模板函式。

例如，想要定義一個物件表示一個平面座標點，則可以：

pair<double, double> p1;

cin >> p1.first >> p1.second;

pair 模板類需要兩個引數：首元素的資料型別和尾元素的資料型別。pair 模

板類物件有兩個成員：first 和second，分別表示首元素和尾元素。

在<utility>中已經定義了pair 上的六個比較運算子：<、>、<=、>=、==、!=，

其規則是先比較first，first 相等時再比較second，這符合大多數應用的

邏輯。當然，也可以通過過載這幾個運算子來重新指定自己的比較邏輯。

除了直接定義一個pair 物件外，如果需要即時生成一個pair 物件，也可以

呼叫在<utility>中定義的一個模板函式：make_pair。make_pair 需要兩

個引數，分別為元素對的首元素和尾元素。

在題1067--Ugly Numbers 中，就可以用pair 來表示推演樹上的結點，用

first 表示結點的值，用second 表示結點是由父結點乘以哪一個因子得到的。

#include <iostream>

#include <queue>

using namespace std;

typedef pair<unsigned long, int> node_type;

int main(){

unsigned long result[1500];

priority_queue< node_type, vector<node_type>,

greater<node_type> > Q;

Q.push( make_pair(1, 2) );

for (int i=0; i<1500; i++){

node_type node = Q.top(); Q.pop();

switch(node.second){

case 2: Q.push( make_pair(node.first*2, 2) );

case 3: Q.push( make_pair(node.first*3, 3) );

case 5: Q.push( make_pair(node.first*5, 5) );

}

result[i] = node.first;

}

int n;

cin >> n;

while (n>0){

cout << result[n-1] << endl;

cin >> n;

}

return 0;

}

<utility>看上去是很簡單的一個頭檔案，但是<utility>的設計中卻濃縮

反映了STL 設計的基本思想。有意深入瞭解和研究STL 的同學，仔細閱讀和

體會這個簡單的標頭檔案，不失為一種入門的途徑。

ACM/ICPC 競賽之STL--vector

在STL 的<vector>標頭檔案中定義了vector（向量容器模板類），vector

容器以連續陣列的方式儲存元素序列，可以將vector 看作是以順序結構實現

的線性表。當我們在程式中需要使用動態陣列時，vector 將會是理想的選擇，

vector 可以在使用過程中動態地增長儲存空間。

vector 模板類需要兩個模板引數，第一個引數是儲存元素的資料型別，第二

個引數是儲存分配器的型別，其中第二個引數是可選的，如果不給出第二個參

數，將使用預設的分配器。

下面給出幾個常用的定義vector 向量物件的方法示例：

vector<int> s;

定義一個空的vector 物件，儲存的是int 型別的元素。

vector<int> s(n);

定義一個含有n 個int 元素的vector 物件。

vector<int> s(first, last);

定義一個vector 物件，並從由迭代器first 和last 定義的序列[first,

last)中複製初值。

vector 的基本操作有：

s[i]

直接以下標方式訪問容器中的元素。

s.front()

返回首元素。

s.back()

返回尾元素。

s.push_back(x)

向表尾插入元素x。

s.size()

返回表長。

s.empty()

當表空時，返回真，否則返回假。

s.pop_back()

刪除表尾元素。

s.begin()

返回指向首元素的隨機存取迭代器。

s.end()

返回指向尾元素的下一個位置的隨機存取迭代器。

s.insert(it, x)

向迭代器it 指向的元素前插入新元素val。

s.insert(it, n, x)

向迭代器it 指向的元素前插入n 個x。

s.insert(it, first, last)

將由迭代器first 和last 所指定的序列[first, last)插入到迭代器it

指向的元素前面。

s.erase(it)

刪除由迭代器it 所指向的元素。

s.erase(first, last)

刪除由迭代器first 和last 所指定的序列[first, last)。

s.reserve(n)

預分配緩衝空間，使儲存空間至少可容納n 個元素。

s.resize(n)

改變序列的長度，超出的元素將會被刪除，如果序列需要擴充套件（原空間小於n），

元素預設值將填滿擴展出的空間。

s.resize(n, val)

改變序列的長度，超出的元素將會被刪除，如果序列需要擴充套件（原空間小於n），

將用val 填滿擴展出的空間。

s.clear()

刪除容器中的所有的元素。

s.swap(v)

將s 與另一個vector 物件v 進行交換。

s.assign(first, last)

將序列替換成由迭代器first 和last 所指定的序列[first, last)。

[first, last)不能是原序列中的一部分。

要注意的是，resize 操作和clear 操作都是對錶的有效元素進行的操作，但

並不一定會改變緩衝空間的大小。

另外，vector 還有其他一些操作如反轉、取反等，不再一下列舉。

vector 上還定義了序列之間的比較操作運算子(>, <, >=, <=, ==, !=)，

可以按照字典序比較兩個序列。

還是來看一些示例程式碼。輸入個數不定的一組整數，再將這組整數按倒序輸出，

如下所示：

#include <iostream>

#include <vector>

using namespace std;

int main(){

vector<int> L;

int x;

while (cin>>x) L.push_back(x);

for (int i=L.size()-1; i>=0; i--) cout << L[i] << " ";

cout << endl;

return 0;

}

ACM/ICPC 競賽之STL--iterator 簡介

iterator(迭代器)是用於訪問容器中元素的指示器，從這個意義上說，

iterator(迭代器)相當於資料結構中所說的“遍歷指標”，也可以把

iterator(迭代器)看作是一種泛化的指標。

STL 中關於iterator(迭代器)的實現是相當複雜的，這裡我們暫時不去詳細

討論關於iterator(迭代器)的實現和使用，而只對iterator(迭代器)做一

點簡單的介紹。

簡單地說，STL 中有以下幾類iterator(迭代器)：

輸入iterator(迭代器)，在容器的連續區間內向前移動，可以讀取容器內任

意值；

輸出iterator(迭代器)，把值寫進它所指向的容器中；

前向iterator(迭代器)，讀取佇列中的值，並可以向前移動到下一位置

(++p,p++)；

雙向iterator(迭代器)，讀取佇列中的值，並可以向前向後遍歷容器；

隨機訪問iterator(迭代器), 可以直接以下標方式對容器進行訪問，

vector 的iterator(迭代器)就是這種iterator(迭代器)；

流iterator(迭代器)，可以直接輸出、輸入流中的值；

每種STL 容器都有自己的iterator(迭代器)子類，下面先來看一段簡單的示

例程式碼：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> s;

for (int i=0; i<10; i++) s.push_back(i);

for (vector<int>::iterator it=s.begin(); it!=s.end();

it++)

cout << *it << " ";

cout << endl;

return 1;

}

vector 的begin()和end()方法都會返回一個vector::iterator 物件，

分別指向vector 的首元素位置和尾元素的下一個位置（我們可以稱之為結束

標誌位置）。

對一個iterator(迭代器)物件的使用與一個指標變數的使用極為相似，或者

可以這樣說，指標就是一個非常標準的iterator(迭代器)。

再來看一段稍微特別一點的程式碼：

#include <iostream>

#include <vector>

using namespace std;

main()

{

vector<int> s;

s.push_back(1);

s.push_back(2);

s.push_back(3);

copy(s.begin(), s.end(), ostream_iterator<int>(cout, "

"));

cout <<endl;

return 1;

}

這段程式碼中的copy 就是STL 中定義的一個模板函式，copy(s.begin(),

s.end(), ostream_iterator<int>(cout, " "));的意思是將由

s.begin()至s.end()(不含s.end())所指定的序列複製到標準輸出流

cout 中，用" "作為每個元素的間隔。也就是說，這句話的作用其實就是將表

中的所有內容依次輸出。

iterator(迭代器)是STL 容器和演算法之間的“膠合劑”，幾乎所有的STL 算

法都是通過容器的iterator(迭代器)來訪問容器內容的。只有通過有效地運

用iterator(迭代器)，才能夠有效地運用STL 強大的演算法功能。

ACM/ICPC 競賽之STL--string

字串是程式中經常要表達和處理的資料，我們通常是採用字元陣列或字元指

針來表示字串。STL 為我們提供了另一種使用起來更為便捷的字串的表達

方式：string。string 類的定義在標頭檔案<string>中。

string 類其實可以看作是一個字元的vector，vector 上的各種操作都可以

適用於string，另外，string 類物件還支援字串的拼合、轉換等操作。

下面先來看一個簡單的例子：

#include <iostream>

#include <string>

using namespace std;

int main(){

string s = "Hello! ", name;

cin >> name;

s += name;

s += '!';

cout << s << endl;

return 0;

}

再以題1064--Parencoding 為例，看一段用string 作為容器，實現由P

程式碼還原括號字串的示例程式碼片段：

int m;

cin >> m; // P 編碼的長度

string str; // 用來存放還原出來的括號字串

int leftpa = 0; // 記錄已出現的左括號的總數

for (int j=0; j<m; j++){

int p;

cin >> p;

for (int k=0; k<p-leftpa; k++) str += '(';

str += ')';

leftpa = p;

}

ACM/ICPC 競賽之STL--stack/queue

stack(棧)和queue(佇列)也是在程式設計中經常會用到的資料容器，STL

為我們提供了方便的stack(棧)的queue(佇列)的實現。

準確地說，STL 中的stack 和queue 不同於vector、list 等容器，而是對

這些容器的重新包裝。這裡我們不去深入討論STL 的stack 和queue 的實現

細節，而是來了解一些他們的基本使用。

1、stack

stack 模板類的定義在<stack>標頭檔案中。

stack 模板類需要兩個模板引數，一個是元素型別，一個容器型別，但只有元

素型別是必要的，在不指定容器型別時，預設的容器型別為deque。

定義stack 物件的示例程式碼如下：

stack<int> s1;

stack<string> s2;

stack 的基本操作有：

入棧，如例：s.push(x);

出棧，如例：s.pop();注意，出棧操作只是刪除棧頂元素，並不返回該元素。

訪問棧頂，如例：s.top()

判斷棧空，如例：s.empty()，當棧空時，返回true。

訪問棧中的元素個數，如例：s.size()

下面是用string 和stack 寫的解題1064--Parencoding 的程式。

#include <iostream>

#include <string>

#include <stack>

using namespace std;

int main(){

int n;

cin >> n;

for (int i=0; i<n; i++){

int m;

cin >> m;

string str;

int leftpa = 0;

for (int j=0; j<m; j++) // 讀入P 編碼，構造括號字串

{

int p;

cin >> p;

for (int k=0; k<p-leftpa; k++) str += '(';

str += ')';

leftpa = p;

}

stack<int> s;

for (string::iterator it=str.begin();

it!=str.end(); it++) { // 構造M 編碼

if (*it=='(') s.push(1);

else{

int p = s.top(); s.pop();

cout << p << " ";

if (!s.empty()) s.top() += p;

}

}

cout << endl;

}

return 0;

}

2、queue

queue 模板類的定義在<queue>標頭檔案中。

與stack 模板類很相似，queue 模板類也需要兩個模板引數，一個是元素類

型，一個容器型別，元素型別是必要的，容器型別是可選的，預設為deque 類

型。

定義queue 物件的示例程式碼如下：

queue<int> q1;

queue<double> q2;

queue 的基本操作有：

入隊，如例：q.push(x); 將x 接到佇列的末端。

出隊，如例：q.pop(); 彈出佇列的第一個元素，注意，並不會返回被彈出元

素的值。

訪問隊首元素，如例：q.front()，即最早被壓入佇列的元素。

訪問隊尾元素，如例：q.back()，即最後被壓入佇列的元素。

判斷佇列空，如例：q.empty()，當佇列空時，返回true。

訪問佇列中的元素個數，如例：q.size()

3、priority_queue

在<queue>標頭檔案中，還定義了另一個非常有用的模板類

priority_queue(優先佇列）。優先佇列與佇列的差別在於優先佇列不是按

照入隊的順序出隊，而是按照佇列中元素的優先權順序出隊（預設為大者優先，

也可以通過指定運算元來指定自己的優先順序）。

priority_queue 模板類有三個模板引數，第一個是元素型別，第二個容器

型別，第三個是比較運算元。其中後兩個都可以省略，預設容器為vector，默

認運算元為less，即小的往前排，大的往後排（出隊時序列尾的元素出隊）。

定義priority_queue 物件的示例程式碼如下：

priority_queue<int> q1;

priority_queue< pair<int, int> > q2; // 注意在兩個尖括號之間

一定要留空格。

priority_queue<int, vector<int>, greater<int> > q3; // 定

義小的先出隊

priority_queue 的基本操作與queue 相同。

初學者在使用priority_queue 時，最困難的可能就是如何定義比較運算元了。

如果是基本資料型別，或已定義了比較運算子的類，可以直接用STL 的less

運算元和greater 運算元——預設為使用less 運算元，即小的往前排，大的先出隊。

如果要定義自己的比較運算元，方法有多種，這裡介紹其中的一種：過載比較運

算符。優先佇列試圖將兩個元素x 和y 代入比較運算子(對less 運算元，呼叫

x<y，對greater 運算元，呼叫x>y)，若結果為真，則x 排在y 前面，y 將先

於x 出隊，反之，則將y 排在x 前面，x 將先出隊。

看下面這個簡單的示例：

#include <iostream>

#include <queue>

using namespace std;

class T{

public:

int x, y, z;

T(int a, int b, int c):x(a), y(b), z(c){}

};

bool operator < (const T &t1, const T &t2){

return t1.z < t2.z; // 按照z 的順序來決定t1 和t2 的順序

}

int main(){

priority_queue<T> q;

q.push(T(4,4,3));

q.push(T(2,2,5));

q.push(T(1,5,4));

q.push(T(3,3,6));

while (!q.empty()){

T t = q.top(); q.pop();

cout << t.x << " " << t.y << " " << t.z << endl;

}

return 0; }

輸出結果為(注意是按照z 的順序從大到小出隊的)：

3 3 6

2 2 5

1 5 4

4 4 3

再看一個按照z 的順序從小到大出隊的例子：

#include <iostream>

#include <queue>

using namespace std;

class T{

public:

int x, y, z;

T(int a, int b, int c):x(a), y(b), z(c)

{

}

};

bool operator > (const T &t1, const T &t2){

return t1.z > t2.z;

}

int main(){

priority_queue<T, vector<T>, greater<T> > q;

q.push(T(4,4,3));

q.push(T(2,2,5));

q.push(T(1,5,4));

q.push(T(3,3,6));

while (!q.empty()){

T t = q.top(); q.pop();

cout << t.x << " " << t.y << " " << t.z << endl;

}

return 0;

}

輸出結果為：

4 4 3

1 5 4

2 2 5

3 3 6

如果我們把第一個例子中的比較運算子過載為：

bool operator < (const T &t1, const T &t2){

return t1.z > t2.z; // 按照z 的順序來決定t1 和t2 的順序

}

則第一個例子的程式會得到和第二個例子的程式相同的輸出結果。

再回顧一下用優先佇列實現的題1067--Ugly Numbers 的程式碼：

#include <iostream>

#include <queue>

using namespace std;

typedef pair<unsigned long int, int> node_type;

int main( int argc, char *argv[] ){

unsigned long int result[1500];

priority_queue< node_type, vector<node_type>,

greater<node_type> > Q;

Q.push( make_pair(1, 3) );

for (int i=0; i<1500; i++){

node_type node = Q.top();

Q.pop();

switch(node.second){

case 3: Q.push( make_pair(node.first*2, 3) );

case 2: Q.push( make_pair(node.first*3, 2) );

case 1: Q.push( make_pair(node.first*5, 1) );

}

result[i] = node.first;

}

int n;

cin >> n;

while (n>0){

cout << result[n-1] << endl;

cin >> n;

}

return 1;

}

ACM/ICPC 競賽之STL--map

在STL 的標頭檔案<map>中定義了模板類map 和multimap，用有序二叉樹來

存貯型別為pair<const Key, T>的元素對序列。序列中的元素以const Key

部分作為標識，map 中所有元素的Key 值都必須是唯一的，multimap 則允許

有重複的Key 值。

可以將map 看作是由Key 標識元素的元素集合，這類容器也被稱為“關聯容

器”，可以通過一個Key 值來快速確定一個元素，因此非常適合於需要按照Key

值查詢元素的容器。

map 模板類需要四個模板引數，第一個是鍵值型別，第二個是元素型別，第三

個是比較運算元，第四個是分配器型別。其中鍵值型別和元素型別是必要的。

map 的基本操作有：

1、定義map 物件，例如：

map<string, int> m;

2、向map 中插入元素對，有多種方法，例如：

m[key] = value;

[key]操作是map 很有特色的操作，如果在map 中存在鍵值為key 的元素對，

則返回該元素對的值域部分，否則將會建立一個鍵值為key 的元素對，值域為

預設值。所以可以用該操作向map 中插入元素對或修改已經存在的元素對的值

域部分。

m.insert( make_pair(key, value) );

也可以直接呼叫insert 方法插入元素對，insert 操作會返回一個pair，當

map 中沒有與key 相匹配的鍵值時，其first 是指向插入元素對的迭代器，

其second 為true；若map 中已經存在與key 相等的鍵值時，其first 是

指向該元素對的迭代器，second 為false。

3、查詢元素對，例如：

int i = m[key];

要注意的是，當與該鍵值相匹配的元素對不存在時，會建立鍵值為key 的元素

對。

map<string, int>::iterator it = m.find(key);

如果map 中存在與key 相匹配的鍵值時，find 操作將返回指向該元素對的迭

代器，否則，返回的迭代器等於map 的end()（參見vector 中提到的begin

和end 操作）。

4、刪除元素對，例如：

m.erase(key);

刪除與指定key 鍵值相匹配的元素對，並返回被刪除的元素的個數。

m.erase(it);

刪除由迭代器it 所指定的元素對，並返回指向下一個元素對的迭代器。

看一段簡單的示例程式碼：

#include<map>

#include<iostream>

using namespace std;

typedef map<int, string, less<int> > M_TYPE;

typedef M_TYPE::iterator M_IT;

typedef M_TYPE::const_iterator M_CIT;

int main(){

M_TYPE MyTestMap;

MyTestMap[3] = "No.3";

MyTestMap[5] = "No.5";

MyTestMap[1] = "No.1";

MyTestMap[2] = "No.2";

MyTestMap[4] = "No.4";

M_IT it_stop = MyTestMap.find(2);

cout << "MyTestMap[2] = " << it_stop->second << endl;

it_stop->second = "No.2 After modification";

cout << "MyTestMap[2] = " << it_stop->second << endl;

cout << "Map contents : " << endl;

for(M_CIT it = MyTestMap.begin(); it != MyTestMap.end();

it++){

cout << it->second << endl;

}

return 0;

}

程式執行的輸出結果為：

MyTestMap[2] = No.2

MyTestMap[2] = No.2 After modification

Map contents :

No.1

No.2 After modification

No.3

No.4

No.5

再看一段簡單的示例程式碼：

#include <iostream>

#include <map>

using namespace std;

int main(){

map<string, int> m;

m["one"] = 1;

m["two"] = 2;

// 幾種不同的insert 呼叫方法

m.insert(make_pair("three", 3));

m.insert(map<string, int>::value_type("four", 4));

m.insert(pair<string, int>("five", 5));

string key;

while (cin>>key){

map<string, int>::iterator it = m.find(key);

if (it==m.end()){

cout << "No such key!" << endl;

}

else{

cout << key << " is " << it->second << endl;

cout << "Erased " << m.erase(key) << endl;

}

}

return 0;

}

ACM/ICPC 競賽之STL--algorithm

<algorithm>無疑是STL 中最大的一個頭檔案，它是由一大堆模板函式組成

的。

下面列舉出<algorithm>中的模板函式：

adjacent_find / binary_search / copy / copy_backward / count

/ count_if / equal / equal_range / fill / fill_n / find /

find_end / find_first_of / find_if / for_each / generate /

generate_n / includes / inplace_merge / iter_swap /

lexicographical_compare / lower_bound / make_heap / max /

max_element / merge / min / min_element / mismatch /

next_permutation / nth_element / partial_sort /

partial_sort_copy / partition / pop_heap / prev_permutation

/ push_heap / random_shuffle / remove / remove_copy /

remove_copy_if / remove_if / replace / replace_copy /

replace_copy_if / replace_if / reverse / reverse_copy /

相關推薦