BZOJ 1924 所驼门王的宝藏【思维建图+强连通缩点+DAG图上做最长路】这题好尼玛综合........

1924: [Sdoi2010]所驼门王的宝藏

Time Limit: 5 Sec   Memory Limit: 128 MB
Submit: 913   Solved: 379
[ Submit][ Status][ Discuss]

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 R C 1 16 20 20 2 300 1,000 1,000 3 500 100,000 100,000 4 2,500 5,000 5,000 5 50,000 5,000 5,000 6 50,000 1,000,000 1,000,000 7 80,000 1,000,000 1,000,000 8 100,000 1,000,000 1,000,000 9 100,000 1,000,000 1,000,000 10 100,000 1,000,000 1,000,000

思路：

1、对于这个题来说，一开始的大方向思路还是比较好建立的。

对于这个题来讲，一个R*C大小的图，有三种门进行传送，一共最多有1e6个门，那么我们不难将思维划到求最长路上边来，而且是一个没有固定源点的最长路。

考虑求一个多源最短路的时间复杂度，对于1e6个点来讲，肯定是不科学的，而且这个题可能会涉及到环路，所以我们肯定不能直接建好图之后就跑最长路。

无论是什么做法去解这个题，那么首先我们肯定是要建好图之后缩点的。

2、那么对于建图，如果直接暴力扫建图的话是O(n^2)的时间复杂度，那么我们考虑每一种门的特性来建图：

①对于种类1，我们将所有点都分行来存，对每一行去建图。然而对于一种极限情况，如果一行中包含了全部的点，那么时间复杂度还是O(N^2);

此时考虑到强连通的特性，其实我们对于一行的种类1的门来讲，其实只要一个代表去建图就好了，因为对于一行的种类1的门，他们肯定属于同一个强连通分量。

②对于种类2，我们将所有点都分列来存，对每一列去建图，同理，我们对于每一列的种类2的门，都拿出一个代表去建图就好。

③对于钟雷3的门，我们直接将其和上一行的，这一行的，和下一行的点进行判断，如果相距的列距离为1，那么就可以建有向边。

这样的建图显然是比较好的方法了。（其实对于种类3的门，我们还可以对每一行二分去建图，但是好像没必要，我跑的结果是2000+ms）；

3、那么对于建好的图，我们Tarjan强连通缩点，在缩点之后，我们得到了一个DAG图。

那么如果我们已经得到了一个DAG图，而且此时求一条最长路。那么我们不妨在DAG图上用拓扑排序的方法来Dp出来到达每一个点的最长路。

设定dp【v】表示到达点v的最长路。那么有：dp【v】=max（dp【u】+a【u】）；这里a【i】表示编号为u的强连通分量中有多少个点。

那么过程维护一下dp数组即可。

ans=max（dp【i】）【1<=i<=scc 】

Ac代码：

#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
struct node2
{
    int from;
    int to;
    int next;
}e[2200600];
int fx[8]={1,-1,0,0,1,-1,1,-1};
int fy[8]={0,0,1,-1,1,-1,-1,1};
struct node
{
    int x,y;
    int op,num;
}now,nex;
int cont;
int x[1200600];
int y[1200600];
int opp[1200600];
vector<int >mp[1020060];
vector<node >s2[1020060];
vector<node >s[1200600];
int degree[1000060];
int head[1000060];
int dfn[1000500];
int low[1005000];
int stack[1000500];
int color[1000500];
int vis[1005000];
int dp[1000500];
int a[1000600];
int n,r,c;
int tot,cnt,sig;
void add(int from,int to)
{
   // printf("%d %d\n",from,to);
    mp[from].push_back(to);
}
void add2(int from,int to)
{
   // printf("add2:------->%d %d\n",from,to);
    e[cont].to=to;
    e[cont].next=head[from];
    head[from]=cont++;
}
void Getmap()
{
    for(int i=1;i<=n;i++)mp[i].clear();
    for(int i=1;i<=r;i++)
    {
        int first=-1;
        for(int j=0;j<s[i].size();j++)
        {
            now=s[i][j];
            if(now.op==1&&first==-1)
            {
                first=now.num;
                for(int z=0;z<s[i].size();z++)
                {
                    nex=s[i][z];
                    if(now.num==nex.num)continue;
                    else
                    {
                        add(now.num,nex.num);
                        if(nex.op==1)add(nex.num,now.num);
                    }
                }
                break;
            }
        }
    }
    for(int i=1;i<=c;i++)
    {
        int first=-1;
        for(int j=0;j<s2[i].size();j++)
        {
            now=s2[i][j];
            if(now.op==2&&first==-1)
            {
                first=now.num;
                for(int z=0;z<s2[i].size();z++)
                {
                    nex=s2[i][z];
                    if(now.num==nex.num)continue;
                    else
                    {
                        add(now.num,nex.num);
                        if(nex.op==2)add(nex.num,now.num);
                    }
                }
                break;
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(opp[i]==3)
        {
            int xx=x[i]-1;
            int size=s[xx].size();
            for(int j=0;j<size;j++)
            {
                now=s[xx][j];
                if(abs(now.y-y[i])<=1)add(i,now.num);
            }
            xx=x[i];
            size=s[xx].size();
            for(int j=0;j<size;j++)
            {
                now=s[xx][j];
                if(abs(now.y-y[i])<=1)add(i,now.num);
            }
            xx=x[i]+1;
            size=s[xx].size();
            for(int j=0;j<size;j++)
            {
                now=s[xx][j];
                if(abs(now.y-y[i])<=1)add(i,now.num);
            }
        }
    }
}
void init()
{
    sig=0;
    cnt=1;
    tot=-1;
    cont=0;
    memset(degree,0,sizeof(degree));
    memset(color,0,sizeof(color));
    memset(stack,0,sizeof(stack));
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(vis,0,sizeof(vis));
}
void Dp_top()
{
    memset(dp,0,sizeof(dp));
    queue<int >s;
    for(int i=1;i<=sig;i++)
    {
        if(degree[i]==0)
        {
            dp[i]=a[i];
            s.push(i);
        }
    }
    int output=0;
    while(!s.empty())
    {
        int u=s.front();
        s.pop();
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            int v=e[i].to;
            dp[v]=max(dp[u]+a[v],dp[v]);
            degree[v]--;
            if(degree[v]==0)s.push(v);
        }
    }
    for(int i=1;i<=sig;i++)output=max(output,dp[i]);
    //printf("ans:%d\n",output);
    printf("%d\n",output);
}
void Tarjan(int u)
{
    vis[u]=1;
    dfn[u]=low[u]=cnt++;
    stack[++tot]=u;
    for(int i=0; i<mp[u].size(); i++)
    {
        int v=mp[u][i];
        if(vis[v]==0)Tarjan(v);
        if(vis[v]==1)low[u]=min(low[u],low[v]);
    }
    if(dfn[u]==low[u])
    {
        sig++;
        do
        {
            color[stack[tot]]=sig;
            vis[stack[tot]]=-1;
        }
        while(stack[tot--]!=u);
    }
}
void Slove()
{
    init();
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==0)Tarjan(i);
    }
    //printf("SCC:%d\n",sig);
    cont=0;
    memset(head,-1,sizeof(head));
    memset(a,0,sizeof(a));
    for(int i=1;i<=n;i++)
    {
        a[color[i]]++;
        for(int j=0;j<mp[i].size();j++)
        {
            int v=mp[i][j];
            if(color[i]!=color[v])
            {
                add2(color[i],color[v]);
                degree[color[v]]++;
            }
        }
    }
    /*
    for(int i=1;i<=sig;i++)
    {
        printf("%d %d\n",i,a[i]);
    }*/
    Dp_top();
}
int main()
{
    while(~scanf("%d%d%d",&n,&r,&c))
    {
        for(int i=1;i<=r;i++)s[i].clear();
        for(int i=1;i<=c;i++)s2[i].clear();
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d",&x[i],&y[i],&opp[i]);
            now.op=opp[i];
            now.num=i;
            now.x=x[i];
            now.y=y[i];
            s[x[i]].push_back(now);
            s2[y[i]].push_back(now);
        }
        Getmap();
        Slove();
    }
}