bzoj 1924 所驼门王的宝藏

题目大意：

有一个r*c的矩阵，上面有n个点有宝藏

每个有宝藏的点上都有传送门

传送门有三种：第一种可以传到该行任意一个有宝藏的点，第二种可以传到该列任意一个有宝藏的点，第三种可以传到周围的八连块上有宝藏的点

现在你可以在任意一个有宝藏的点开始，求你最多可以经过多少个不同的藏宝点

每个藏宝点可以多次进入，每个传送门可以多次使用

思路：

很容易可以看出这个矩阵并没有什么卵用

而此题的关键在于如何建图，建图所用数组见注释

建完之后，可以使用tarjan算法之一的求强连通分量

因为对于每个强连通分量，只要到达任意一个点，就可以到达其余所有点

然后我们缩点，把每个强连通分量都缩为一个点

再重新建图

这样图就会变成DAG，然后求一下最长链并统计每一个强连通分量内有几个点就好了

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #include<cstring>
 #include<cstdlib>
 #include<queue>
 #include<vector>
 #include<stack>
 #include<set>
 #include<map>
 #define inf 2147483611
 #define ll long long
 #define MAXN 101001
 using namespace std;
 inline int read()
 {
     int x=,f=;
     char ch;ch=getchar();
     while(!isdigit(ch)) {if(ch=='-') f=-;ch=getchar();}
     while(isdigit(ch)) {x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int dx[]={,,,-,-,-,,},dy[]={,,-,,,-,,-};//八连块用数组
 map <int,int> m[*MAXN];//记录每个位置是否有藏宝点，因为数组开不下只能用map
 vector <int> vr[*MAXN],vc[*MAXN];//记录每行每列所有藏宝点，用vector方便记录
 int n,r,c;
 int x[MAXN],y[MAXN];//记录每个点的横纵坐标
 short t[MAXN];//记录每个点的传送门种类
 int to[*MAXN],next[*MAXN],first[MAXN],cnt;//第一次图用邻接表
 int to0[*MAXN],next0[*MAXN],first0[MAXN];//DAG第二次图用邻接表
 int low[MAXN],dfn[MAXN],stp,scc,now,st[MAXN],top;//tarjan用数组
 //scc记录一共有多少强连通分量，stp记录步数，st、top记录栈
 int num[MAXN],blg[MAXN];//num记录每个强连通分量中有多少个点，blg记录每个点属于那个强连通分量
 int deep[MAXN];//求最长链用，记录每个强连通分量能延伸的最长长度
 int ans;
 bool vis[MAXN];//第一次为tarjan用，第二次求最长链用
 void add(int u,int v)//第一次建图
 {
     if(u==v) return ;
     to[++cnt]=v,next[cnt]=first[u],first[u]=cnt;
 }
 void ADD(int u,int v) {to0[++cnt]=v,next0[cnt]=first0[u],first0[u]=cnt;}//第二次建图
 void build()//第一次建图
 {
     int tmp,s;
     for(int i=;i<=r;i++)//同一行的藏宝图
     {
         tmp=,s=vr[i].size();
         for(int j=;j<s;j++) if(t[vr[i][j]]==) {tmp=vr[i][j];break;}
         for(int j=;j<s;j++)
         {
             add(tmp,vr[i][j]);
             if(t[vr[i][j]]==) add(vr[i][j],tmp);//不用连所有边，只需要这样就可以满足要求
         }
     }
     for(int i=;i<=c;i++)//同一列，方法同上
     {
         tmp=,s=vc[i].size();
         for(int j=;j<s;j++) if(t[vc[i][j]]==) {tmp=vc[i][j];break;}
         for(int j=;j<s;j++)
         {
             add(tmp,vc[i][j]);
             if(t[vc[i][j]]==) add(vc[i][j],tmp);
         }
     }
     for(int i=;i<=n;i++)//八连块
         if(t[i]==)
             for(int j=;j<;j++) if(m[x[i]+dx[j]][y[i]+dy[j]]) add(i,m[x[i]+dx[j]][y[i]+dy[j]]);
 }
 void tarjan(int x)//tarjan求强连通分量
 {
     low[x]=dfn[x]=++stp;
     st[++top]=x;vis[x]=;
     for(int i=first[x];i;i=next[i])
         if(!dfn[to[i]])
             {tarjan(to[i]);low[x]=min(low[x],low[to[i]]);}//在栈外且未被访问过
         else if(vis[to[i]]) low[x]=min(low[x],dfn[to[i]]);//在栈内
     if(low[x]==dfn[x])
     {
         scc++;now=;
         while(now!=x)
         {
             now=st[top--];vis[now]=;
             blg[now]=scc;num[scc]++;
         }
     }
 }
 void BUILD()//第二次建图
 {
     for(int i=;i<=n;i++)
         for(int j=first[i];j;j=next[j])
             if(blg[i]!=blg[to[j]]) ADD(blg[i],blg[to[j]]);
 }
 void dp(int x)//求最长链
 {
     vis[x]=;
     for(int i=first0[x];i;i=next0[i])
     {
         if(!vis[to0[i]]) dp(to0[i]);
         deep[x]=max(deep[x],deep[to0[i]]);//延伸
     }
     deep[x]+=num[x];
     ans=max(ans,deep[x]);
 }
 int main()
 {
     n=read(),r=read(),c=read();
     for(int i=;i<=n;i++)
     {
         x[i]=read(),y[i]=read(),t[i]=read();
         m[x[i]][y[i]]=i;
         vr[x[i]].push_back(i);
         vc[y[i]].push_back(i);
     }
     build();
     for(int i=;i<=n;i++)
         if(!dfn[i]) tarjan(i);
     cnt=;
     BUILD();
     for(int i=;i<=scc;i++)
         if(!vis[i]) dp(i);
     printf("%d",ans);
 }