BZOJ 1093 [ZJOI2007]最大半连通子图

  1 #include <set>
  2 #include <stack>
  3 #include <cstdio>
  4 
  5 using namespace std;
  6 
  7 const size_t Max_N(100050);
  8 const size_t Max_M(1000050);
  9 
 10 typedef pair<unsigned int, unsigned int> pll;
 11 
 12 inline
 13 unsigned int Min(const unsigned int &a, const unsigned int &b)
 14 {
 15     return a < b ? a : b;
 16 }
 17 
 18 void Get_Val(unsigned int &ret)
 19 {
 20     ret = 0;
 21     char ch;
 22     while ((ch = getchar()), (ch > ‘9‘ || ch < ‘0‘))
 23         ;
 24     do
 25     {
 26         (ret *= 10) += ch - ‘0‘;
 27     }
 28     while ((ch = getchar()), (ch >= ‘0‘ && ch <= ‘9‘));
 29 }
 30 
 31 size_t N, M;
 32 unsigned int MOD;
 33 unsigned int Head[Max_N];
 34 unsigned int To[Max_M], Next[Max_M];
 35 
 36 unsigned int SCC_Total;
 37 unsigned int SCC_Number[Max_N];
 38 unsigned int SCC_Weight[Max_N];
 39 
 40 unsigned int SCC_Edge_Total;
 41 unsigned int SCC_Head[Max_N];
 42 unsigned int SCC_To[Max_M], SCC_Next[Max_M];
 43 unsigned int SCC_Degree[Max_N];
 44 
 45 stack<unsigned int> S;
 46 
 47 inline
 48 void Add_Edge(const size_t &Total, const size_t &s, const size_t &t)
 49 {
 50     To[Total] = t, Next[Total] = Head[s], Head[s] = Total;
 51 }
 52 
 53 inline
 54 void SCC_Add_Edge(const size_t &s, const size_t &t)
 55 {
 56     ++SCC_Edge_Total, SCC_To[SCC_Edge_Total] = t, SCC_Next[SCC_Edge_Total] = SCC_Head[s], SCC_Head[s] = SCC_Edge_Total;
 57 }
 58 
 59 void init()
 60 {
 61     Get_Val(N);
 62     Get_Val(M);
 63     Get_Val(MOD);
 64     
 65     size_t A, B;
 66     for (size_t i = 1;i <= M;++i)
 67     {
 68         Get_Val(A);
 69         Get_Val(B);
 70         Add_Edge(i, A, B);
 71     }
 72 }
 73 
 74 unsigned int Dfs_Clock;
 75 unsigned int Pre[Max_N], Low_Link[Max_N];
 76 
 77 void Tarjan(const size_t &u)
 78 {
 79     size_t v;
 80     Pre[u] = Low_Link[u] = ++Dfs_Clock;
 81     S.push(u);
 82     
 83     for (size_t i = Head[u];i;i = Next[i])
 84     {
 85         v = To[i];
 86         if (!Pre[v])
 87         {
 88             Tarjan(v);
 89             Low_Link[u] = Min(Low_Link[u], Low_Link[v]);
 90         }
 91         else
 92             if (!SCC_Number[v])
 93                 Low_Link[u] = Min(Low_Link[u], Pre[v]);
 94     }
 95     
 96     if (Pre[u] == Low_Link[u])
 97     {
 98         ++SCC_Total;
 99         while (true)
100         {
101             v = S.top();
102             S.pop();
103             SCC_Number[v] = SCC_Total;
104             ++SCC_Weight[SCC_Total];
105             if (u == v)
106                 break;
107         }
108     }
109 }
110 
111 void Make_Graph()
112 {
113     set<pll> Judge;
114     size_t t;
115     
116     for (size_t i = 1;i <= N;++i)
117         if (!Pre[i])
118             Tarjan(i);
119     for (size_t s = 1;s <= N;++s)
120         for (size_t i = Head[s];i;i = Next[i])
121         {
122             t = To[i];
123             if (SCC_Number[s] != SCC_Number[t])
124                 if (!Judge.count(pll(SCC_Number[s], SCC_Number[t])))
125                 {
126                     SCC_Add_Edge(SCC_Number[s], SCC_Number[t]);
127                     ++SCC_Degree[SCC_Number[t]];
128                     Judge.insert(pll(SCC_Number[s], SCC_Number[t]));
129                 }
130         }
131 }
132 
133 unsigned int F[Max_N];
134 unsigned int Cnt[Max_N];
135 void dp()
136 {
137     unsigned int Max_Point(0);
138     unsigned int Max_Cnt(0);
139     for (size_t i = 1;i <= SCC_Total;++i)
140         if (!SCC_Degree[i])
141         {
142             S.push(i);
143             F[i] = SCC_Weight[i];
144             Cnt[i] = 1;
145         }
146     
147     unsigned int Top;
148     unsigned int v;
149     while (S.size())
150     {
151         Top = S.top();
152         S.pop();
153         for (size_t i = SCC_Head[Top];i;i = SCC_Next[i])
154         {
155             v = SCC_To[i];
156             if (F[v] < F[Top] + SCC_Weight[v])
157             {
158                 F[v] = F[Top] + SCC_Weight[v];
159                 Cnt[v] = Cnt[Top];
160             }
161             else
162                 if (F[v] == F[Top] + SCC_Weight[v])
163                     (Cnt[v] += Cnt[Top]) %= MOD;
164             --SCC_Degree[v];
165             if (!SCC_Degree[v])
166                 S.push(v);
167         }
168     }
169     
170     for (size_t i = 1;i <= SCC_Total;++i)
171         if (F[i] > Max_Point)
172         {
173             Max_Point = F[i];
174             Max_Cnt = Cnt[i];
175         }
176         else
177             if (F[i] == Max_Point)
178                 (Max_Cnt += Cnt[i]) %= MOD;
179     printf("%u\n%u", Max_Point, Max_Cnt % MOD);
180 }
181 
182 int main()
183 {
184     init();
185     
186     Make_Graph();
187     dp();
188     
189     return 0;
190 }