7.1拓扑，子集排列和搜索

拓扑排序指找入度为零的点，删去此点的边，不断重复最后得到点的访问顺序

 1 int first[N];
 2 int deeg[N];//表示入度
 3 void add(int u,int v){
 4     edge[++cnt].to=v;
 5     deeg[v]++;
 6     edge[cnt].next=first[u];
 7     first[u]=cnt;
 8 }
 9 void tuopu(){
10     queue<int>q;
11     for(int i=1;i<=n;++i){
12         if(deeg[i]==0){
13             q.push(i);
14             break;
15         }
16     }
17     while(!q.empty()){
18         int dex=q.front();
19         cout<<dex<<' ';
20         q.pop();
21         deeg[dex]--;
22         for(int i=first[dex];i!=0;i=edge[i].next){
23             deeg[edge[i].to]--;
24         }
25         for(int i=1;i<=n;++i){
26             if(deeg[i]==0){
27                 q.push(i);
28                 break;
29             }
30         }
31     }
32 }//bfs的拓扑排序 

全排列问题，暴力递归枚举就行，这里介绍新的函数简单实现

next_permutation是将区间数组变成排列序更大的序列，如果无法变得更大则返回false；
于此相对的还有pre_permutation变小

int arr[110][110];
int a[110];
int main(){
    int n；
    cin>>n;
        for(int i=0;i<n;++i){
            cin>>arr[i];
        }
　　sort(arr,arr+n);
    do{
        for(int i=0;i<n;++i){
               cout<<arr[i]<<' ';
            }
            cout<<endl;
    }while(next_permutation(a,a+n));
    return 0;
}                                 

子集问题有三种方法：增量构造法，位向量，二进制法（重点）

二进制表示是根据一个数的二进制位来表示集合，0表示此位下标不在集合，1表示存在；

通过这种方法可以很方便的求出集合的交集&和并集|

 1 void printsbt(int n,int s){
 2     for(int i=0;i<n;++i){
 3         if(s&(1<<i)){
 4             cout<<arr[i]<<' ';
 5         }
 6     }
 7     cout<<endl;
 8 }
 9 int main()
10 {
11     int n;
12     cin>>n;
13     for(int i=0;i<n;++i){
14         cin>>arr[i];
15     }
16     for(int i=1;i<(1<<n);i++){
17         printsbt(n,i);//每一种i表示一种集合状态
18     }
19     return 0;
20  } //二进制子集生成 

搜索主要是dfs（深度，一般用在暴力递归上），bfs（广度，比较常用，一般用来求最短路）

dfs用栈来实现，因为递归就是栈，所以一般都是递归，bfs用队列来实现，一般以队列为空或找到结果来作为base case；

------------------------------------------------------

离散化，对数大小不关心，只对数之间的大小关系有关，可以用离散化，将大数映射到较小的数上，如求逆序对

 1 int arr[500005];
 2 int temp[500005]; 
 3 int main()
 4 {
 5     int n;
 6     cin>>n;
 7     for(int i=0;i<n;++i){
 8         cin>>arr[i];
 9         temp[i]=arr[i];
10     }
11     sort(temp,temp+n);
12     unique(temp,temp+n);
13     for(int i=0;i<n;++i){
14         arr[i]=lower_bound(temp,temp+n,arr[i])-temp;
15     }
16     return 0;
17 }//离散

 

标签：arr,递归,temp,int,拓扑,7.1,子集,110,void
来源： https://www.cnblogs.com/xuanru/p/16436234.html