BZOJ1924:[SDOI2010]所驼门王的宝藏(强连通分量,拓扑排序)

Description

Input

第一行给出三个正整数 N, R, C。 以下 N 行，每行给出一扇传送门的信息，包含三个正整数xi, yi, Ti，表示该传送门设在位于第 xi行第yi列的藏宝宫室，类型为 Ti。Ti是一个1~3间的整数， 1表示可以传送到第 xi行任意一列的“横天门”，2表示可以传送到任意一行第 yi列的“纵寰门”，3表示可以传送到周围 8格宫室的“八方门”。 保证 1≤xi≤R，1≤yi≤C，所有的传送门位置互不相同。

Output

只有一个正整数，表示你确定的路线所经过不同藏宝宫室的最大数目。

Sample Input

10 7 7
2 2 1
2 4 2
1 7 2
2 7 3
4 2 2
4 4 1
6 7 3
7 7 1
7 5 2
5 2 1

Sample Output

9

HINT

N<=100000， R<=100000， C<=100000

Solution

一开始的正解的想法让我以为边数太多然后叉掉了……其实是可以过的……

很容易可以想到做法就是门和门之间连边，然后tarjan缩个点再拓扑排序跑个最长路就完事了。不过直接连边$n^2$肯定会GG。

对于同一行的门来说，横门间显然可以相互传送，只需要选定一个横门，然后向这一行的其他横门连双向边，向这一行的其他门连单向边，这样就可以保证缩点后横门在一个强连通分量里了。列同理。

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<vector>
 #include<queue>
 #include<map>
 #define N (100009)
 using namespace std;

 struct Node{int x,y,t,id;}a[N];
 struct Edge{int to,next;}edge[N*];
 int n,m,r,c,e1[N*],e2[N*],Ind[N],dp[N];
 int head[N],num_edge;
 int Dfn[N],Low[N],stack[N],ID[N],Num[N];
 int top,id_num,dfs_num;
 int dx[]={,,,,,,-,-,-},dy[]={,,-,,,-,,,-};
 vector<int>Line[N*],List[N*];
 map<int,int>Map[N*];
 queue<int>q;
 bool vis[N];

 void add(int u,int v)
 {
     edge[++num_edge].to=v;
     edge[num_edge].next=head[u];
     head[u]=num_edge;
     if (!m) e1[num_edge]=u,e2[num_edge]=v;
 }

 void Tarjan(int x)
 {
     Dfn[x]=Low[x]=++dfs_num;
     stack[++top]=x; vis[x]=true;
     for (int i=head[x]; i; i=edge[i].next)
         if (!Dfn[edge[i].to])
             Tarjan(edge[i].to),Low[x]=min(Low[x],Low[edge[i].to]);
         else if (vis[edge[i].to])
             Low[x]=min(Low[x],Dfn[edge[i].to]);
     if (Low[x]==Dfn[x])
     {
         vis[x]=false; ID[x]=++id_num; Num[id_num]++;
         while (stack[top]!=x)
         {
             vis[stack[top]]=false;
             Num[id_num]++;
             ID[stack[top--]]=id_num;
         }
         top--;
     }
 }

 void Add()
 {
     for (int i=; i<=r; ++i)
     {
         int x=,sz=Line[i].size();
         for (int j=; j<sz; ++j)
             if (a[Line[i][j]].t==){x=Line[i][j]; break;}
         if (!x) continue;
         for (int j=; j<sz; ++j)
             if (Line[i][j]!=x)
             {
                 add(x,Line[i][j]);
                 if (a[Line[i][j]].t==) add(Line[i][j],x);
             }
     }
     for (int i=; i<=c; ++i)
     {
         int x=,sz=List[i].size();
         for (int j=; j<sz; ++j)
             if (a[List[i][j]].t==){x=List[i][j]; break;}
         if (!x) continue;
         for (int j=; j<sz; ++j)
             if (List[i][j]!=x)
             {
                 add(x,List[i][j]);
                 if (a[List[i][j]].t==) add(List[i][j],x);
             }
     }
     for (int i=; i<=n; ++i)
         if (a[i].t==)
         {
             int x=a[i].x,y=a[i].y;
             for (int j=; j<=; ++j)
             {
                 int t=Map[x+dx[j]][y+dy[j]];
                 if (t) add(i,t);
             }
         }
 }

 void Toposort()
 {
     int ans=;
     for (int i=; i<=id_num; ++i) ans=max(ans,Num[i]);
     for (int i=; i<=id_num; ++i) if (!Ind[i]) q.push(i),dp[i]=Num[i];
     while (!q.empty())
     {
         int x=q.front(); q.pop();
         for (int i=head[x]; i; i=edge[i].next)
         {
             int y=edge[i].to; Ind[y]--;
             if(!Ind[y]) q.push(y);
             dp[y]=max(dp[y],dp[x]+Num[y]);
             ans=max(ans,dp[y]);
         }
     }
     printf("%d\n",ans);
 }

 int main()
 {
     scanf("%d%d%d",&n,&r,&c);
     for (int i=; i<=n; ++i)
     {
         scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].t);
         Line[a[i].x].push_back(i);
         List[a[i].y].push_back(i);
         Map[a[i].x][a[i].y]=i;
     }
     Add();
     for (int i=; i<=n; ++i)
         if (!Dfn[i]) Tarjan(i);

     memset(head,,sizeof(head));
     m=num_edge; num_edge=;
     for (int i=; i<=m; ++i)
         if (ID[e1[i]]!=ID[e2[i]])
             add(ID[e1[i]],ID[e2[i]]),Ind[ID[e2[i]]]++;
     Toposort();
 }