7.1拓扑，子集排列和搜索

2022-07-01 23:31:09 阅读：131 来源： 互联网

标签：arr 递归 temp int 拓扑 7.1 子集 110 void

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

 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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

7.1拓扑，子集排列和搜索