csu1617]强连通分量

题意:定义域属于一个集合S={0,1,...,n-1},求S的子集个数,满足以子集的元素为定义域的函数P(x)的值域等于子集本身。

思路:以元素为点,x到P(x)连一条有向边,不难发现,如果有一个有向环,那么环上的元素构成的集合就满足要求。所以问题转化为求有向环的个数,由于有向环之间不可能有交点(同一个点有且仅有一条出边),所以答案就是2^有向环的个数(如果选了有向环上的一点,那么整个有向环必须全部选)。所以只要用tarjan算法统计点数大于等于2的强连通分量个数然后加上自环的,就得到了有向环的个数了。

  1 #pragma comment(linker, "/STACK:10240000,10240000")
  2
  3 #include <iostream>
  4 #include <cstdio>
  5 #include <algorithm>
  6 #include <cstdlib>
  7 #include <cstring>
  8 #include <map>
  9 #include <queue>
 10 #include <deque>
 11 #include <cmath>
 12 #include <vector>
 13 #include <ctime>
 14 #include <cctype>
 15 #include <stack>
 16 #include <set>
 17 #include <bitset>
 18 #include <functional>
 19 #include <numeric>
 20 #include <stdexcept>
 21 #include <utility>
 22
 23 using namespace std;
 24
 25 #define mem0(a) memset(a, 0, sizeof(a))
 26 #define mem_1(a) memset(a, -1, sizeof(a))
 27 #define lson l, m, rt << 1
 28 #define rson m + 1, r, rt << 1 | 1
 29 #define define_m int m = (l + r) >> 1
 30 #define rep_up0(a, b) for (int a = 0; a < (b); a++)
 31 #define rep_up1(a, b) for (int a = 1; a <= (b); a++)
 32 #define rep_down0(a, b) for (int a = b - 1; a >= 0; a--)
 33 #define rep_down1(a, b) for (int a = b; a > 0; a--)
 34 #define all(a) (a).begin(), (a).end()
 35 #define lowbit(x) ((x) & (-(x)))
 36 #define constructInt4(name, a, b, c, d) name(int a = 0, int b = 0, int c = 0, int d = 0): a(a), b(b), c(c), d(d) {}
 37 #define constructInt3(name, a, b, c) name(int a = 0, int b = 0, int c = 0): a(a), b(b), c(c) {}
 38 #define constructInt2(name, a, b) name(int a = 0, int b = 0): a(a), b(b) {}
 39 #define pchr(a) putchar(a)
 40 #define pstr(a) printf("%s", a)
 41 #define sstr(a) scanf("%s", a)
 42 #define sint(a) scanf("%d", &a)
 43 #define sint2(a, b) scanf("%d%d", &a, &b)
 44 #define sint3(a, b, c) scanf("%d%d%d", &a, &b, &c)
 45 #define pint(a) printf("%d\n", a)
 46 #define test_print1(a) cout << "var1 = " << a << endl
 47 #define test_print2(a, b) cout << "var1 = " << a << ", var2 = " << b << endl
 48 #define test_print3(a, b, c) cout << "var1 = " << a << ", var2 = " << b << ", var3 = " << c << endl
 49 #define mp(a, b) make_pair(a, b)
 50 #define pb(a) push_back(a)
 51
 52 typedef long long LL;
 53 typedef pair<int, int> pii;
 54 typedef vector<int> vi;
 55
 56 const int dx[8] = {0, 0, -1, 1, 1, 1, -1, -1};
 57 const int dy[8] = {-1, 1, 0, 0, 1, -1, 1, -1 };
 58 const int maxn = 1e4 + 7;
 59 const int md = 1e9 + 7;
 60 const int inf = 1e9 + 7;
 61 const LL inf_L = 1e18 + 7;
 62 const double pi = acos(-1.0);
 63 const double eps = 1e-6;
 64
 65 template<class T>T gcd(T a, T b){return b==0?a:gcd(b,a%b);}
 66 template<class T>bool max_update(T &a,const T &b){if(b>a){a = b; return true;}return false;}
 67 template<class T>bool min_update(T &a,const T &b){if(b<a){a = b; return true;}return false;}
 68 template<class T>T condition(bool f, T a, T b){return f?a:b;}
 69 template<class T>void copy_arr(T a[], T b[], int n){rep_up0(i,n)a[i]=b[i];}
 70 int make_id(int x, int y, int n) { return x * n + y; }
 71
 72 struct Graph {
 73     vector<vector<int> > G;
 74     void clear() { G.clear(); }
 75     void resize(int n) { G.resize(n + 2); }
 76     void add(int u, int v) { G[u].push_back(v); }
 77     vector<int> & operator [] (int u) { return G[u]; }
 78 };
 79 Graph G;
 80 int n, m;
 81 int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
 82 stack<int> S;
 83 int cnt[maxn], a[maxn];
 84
 85 void dfs(int u) {
 86     pre[u] = lowlink[u] = ++ dfs_clock;
 87     S.push(u);
 88     rep_up0(i, G[u].size()) {
 89         int v = G[u][i];
 90         if (!pre[v]) {
 91             dfs(v);
 92             min_update(lowlink[u], lowlink[v]);
 93         }
 94         else if (!sccno[v]) {
 95             min_update(lowlink[u], pre[v]);
 96         }
 97     }
 98     if (lowlink[u] == pre[u]) {
 99         scc_cnt ++;
100         for(;; ) {
101             int x = S.top(); S.pop();
102             sccno[x] = scc_cnt;
103             if (x == u) break;
104         }
105     }
106 }
107 int find_scc(int n) {
108     dfs_clock = scc_cnt = 0;
109     mem0(sccno);
110     mem0(pre);
111     rep_up0(i, n) {
112         if (!pre[i]) dfs(i);
113     }
114     mem0(cnt);
115     int c = 0;
116     rep_up0(i, n) {
117         cnt[sccno[i]] ++;
118     }
119     rep_up1(i, scc_cnt) {
120         if (cnt[i] >= 2) c ++;
121     }
122     rep_up0(i, n) if (G[i].size() == 0) c ++;
123     int ans = 1;
124     rep_up0(i, c) {
125         ans = (ans << 1) % md;
126     }
127     return ans;
128 }
129
130 int P(int x) {
131     int ans = 0;
132     rep_up0(i, m + 1) {
133         ans = (ans * x + a[m - i]) % n;
134     }
135     return ans;
136 }
137
138 int main() {
139     //freopen("in.txt", "r", stdin);
140     int T;
141     cin >> T;
142     while (T --) {
143         cin >> n >> m;
144         G.clear();
145         G.resize(n);
146         rep_up0(i, m + 1) sint(a[i]);
147         rep_up0(i, n) {
148             int x = P(i);
149             if (x != i) G.add(i, x);
150         }
151         cout << find_scc(n) << endl;
152     }
153     return 0;
154 }

时间: 2024-10-13 01:15:07

csu1617]强连通分量的相关文章

Kosaraju算法解析: 求解图的强连通分量

1. 定义 连通分量:在无向图中,即为连通子图. 上图中,总共有四个连通分量.顶点A.B.C.D构成了一个连通分量,顶点E构成了一个连通分量,顶点F,G和H,I分别构成了两个连通分量. 强连通分量:有向图中,尽可能多的若干顶点组成的子图中,这些顶点都是相互可到达的,则这些顶点成为一个强连通分量. 上图中有三个强连通分量,分别是a.b.e以及f.g和c.d.h. 2. 连通分量的求解方法 对于一个无向图的连通分量,从连通分量的任意一个顶点开始,进行一次DFS,一定能遍历这个连通分量的所有顶点.所以

POJ 2186 Popular Cows 强连通分量模板

题意 强连通分量,找独立的块 强连通分量裸题 #include <cstdio> #include <cstdlib> #include <cstring> #include <string> #include <algorithm> #include <iostream> using namespace std; const int maxn = 50005; int n, m; struct Edge { int v, next;

USACO network of school 强连通分量

这个题的意思是有一个有向图, 每个顶点可以发送软件到与其相连的顶点上, 现在问1,至少发送给几个顶点能满足所有顶点都收到软件, 2:如果想让这个图变成强连通图,至少添几条边.  特例是给定的图是一个强连通图的话答案是1, 0. 一般情况下我们先将这个图的强连通分量求出来缩成一个点然后统计入度为0的点和出度为0的点的个数, 答案一就是入度为0的点的个数, 答案就是他们两个之间的最大值.代码如下: /* ID: m1500293 LANG: C++ PROG: schlnet */ #include

强连通分量(学习心得)

定义:有向图强连通分量:在有向图G中,如果两个顶点vi,vj间(vi>vj)有一条从vi到vj的有向路径,同时还有一条从vj到vi的有向路径,则称两个顶点强连通如果有向图G的每两个顶点都强连通,称G是一个强连通图.有向图的极大强连通子图,称为强连通分量. 求强连通分量: vector<int>pic[maxn]; int dfn[maxn],low[maxn],ans[maxn]; bool ins[maxn]; stack<int>st; int dind=0,block=

POJ 2186:Popular Cows(强连通分量)

[题目链接] http://poj.org/problem?id=2186 [题目大意] 给出一张有向图,问能被所有点到达的点的数量 [题解] 我们发现能成为答案的,只有拓扑序最后的SCC中的所有点, 那么我们从其中一个点开始沿反图dfs,如果能访问到全图, 则答案为其所在SCC的大小,否则为0. [代码] #include <cstdio> #include <algorithm> #include <vector> #include <cstring>

【学习整理】Tarjan:强连通分量+割点+割边

Tarjan求强连通分量 在一个有向图中,如果某两点间都有互相到达的路径,那么称中两个点强联通,如果任意两点都强联通,那么称这个图为强联通图:一个有向图的极大强联通子图称为强联通分量.   算法可以在 的时间内求出一个图的所有强联通分量. 表示进入结点 的时间 表示从 所能追溯到的栈中点的最早时间 如果某个点 已经在栈中则更新  否则对 进行回溯,并在回溯后更新  #include<iostream> #include<cstdlib> #include<cstdio>

【强连通分量】tarjan算法及kosaraju算法+例题

阅读前请确保自己知道强连通分量是什么,本文不做赘述. Tarjan算法 一.算法简介 Tarjan算法是一种由Robert Tarjan提出的求有向图强连通分量的时间复杂度为O(n)的算法. 首先我们要知道两个概念:时间戳(DFN),节点能追溯到的最早的栈中节点的时间戳(LOW).顾名思义,DFN就是在搜索中某一节点被遍历到的次序号(dfs_num),LOW就是某一节点在栈中能追溯到的最早的父亲节点的搜索次序号. Tarjan算法是基于深度优先搜索的算法.在搜索过程中把没有Tarjan过的点入栈

有向图的强连通分量(tarjan算法)

强连通分量 有向图强连通分量:在有向图G中,如果两个顶点vi,vj间(vi>vj)有一条从vi到vj的有向路径,同时还有一条从vj到vi的有向路径,则称两个顶点强连通(strongly connected).如果有向图G的每两个顶点都强连通,称G是一个强连通图.有向图的极大强连通子图,称为强连通分量(strongly connected components). 考虑强连通分量C,设其中第一个被发现的点为x,则,C中其他的点都是x的后代.我们希望在x访问完成时立即输出C(可以同时记录C,输出代表

【BZOJ1051】1051: [HAOI2006]受欢迎的牛 tarjan求强连通分量+缩点

Description 每一头牛的愿望就是变成一头最受欢迎的牛.现在有N头牛,给你M对整数(A,B),表示牛A认为牛B受欢迎. 这种关系是具有传递性的,如果A认为B受欢迎,B认为C受欢迎,那么牛A也认为牛C受欢迎.你的任务是求出有多少头牛被所有的牛认为是受欢迎的. Input 第一行两个数N,M. 接下来M行,每行两个数A,B,意思是A认为B是受欢迎的(给出的信息有可能重复,即有可能出现多个A,B) Output 一个数,即有多少头牛被所有的牛认为是受欢迎的. Sample Input 3 3