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

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

Time Limit: 5 Sec  Memory Limit: 128 MB
Submit: 1285  Solved: 574
[Submit][Status][Discuss]

Description

Input

第一行给出三个正整数 N, R, C。 以下 N 行，每行给出一扇传送门的信息，包含三个正整数xi, yi, Ti，表示该传送门设在位于第 xi行第yi列的藏宝宫室，类型为 Ti。Ti是一个1~3间的整数， 1表示可以传送到第 xi行任意一列的“横天门”，2表示可以传送到任意一行第 yi列的“纵寰门”，3表示可以传送到周围 8格宫室的“自由<x>门”。 保证 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

Source

题解

按照题意建好有向边, 跑一遍 $Tarjan$ 缩成 $DAG$ 之后直接 $O(n)$  $DP$ 一遍求最大值即可.

至于快速建边, 可以用 $std::set$ 维护同一行/同一列的所有节点编号, 二维 $std::map$ 维护各个节点的位置. 不过如果所有点都在同一行的话可能会$GG$

参考代码

GitHub

#include <set>
#include <map>
#include <stack>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

const int MAXV=1e5+10;
const int MAXE=5e6;

struct Edge{
    int from;
    int to;
    Edge* next;
};
Edge E[MAXE];
Edge* head[MAXV];
Edge* top=E;

struct Node{
    int x;
    int y;
    int type;
};
Node N[MAXV];

int v;
int c;
int r;
int ans;
int clk;
int scc;
int dp[MAXV];
int dfn[MAXV];
int low[MAXV];
int size[MAXV];
int belong[MAXV];

bool inStack[MAXV];

std::stack<int> s;
std::map< int, std::set<int> > sx,sy;
std::map< int, std::map<int,int> > m;

void Build();
void DFS(int);
void Tarjan(int);
void SweepEdge();
void Initialize();
void Insert(int,int);

int main(){
    Initialize();
    Build();
    for(int i=1;i<=v;i++){
        if(dfn[i]==0)
            Tarjan(i);
    }
    SweepEdge();
    for(int i=1;i<=v;i++){
        if(dp[i]==0)
            DFS(i);
    }
    printf("%d
",ans);
    return 0;
}

void Initialize(){
    scanf("%d%d%d",&v,&r,&c);
    for(int i=1;i<=v;i++){
        scanf("%d%d%d",&N[i].x,&N[i].y,&N[i].type);
        sx[N[i].x].insert(i);
        sy[N[i].y].insert(i);
        (m[N[i].x])[N[i].y]=i;
    }
}

void DFS(int root){
    if(dp[root]!=0)
        return;
    else{
        dp[root]=size[root];
        int max=0;
        for(Edge* i=head[root];i!=NULL;i=i->next){
            DFS(i->to);
            max=std::max(max,dp[i->to]);
        }
        dp[root]+=max;
        ans=std::max(dp[root],ans);
    }
}

void SweepEdge(){
    // puts("SE");
    Edge* ed=top;
    top=E;
    memset(head,0,sizeof(head));
    for(Edge* i=E;i!=ed;i++){
        if(belong[i->from]!=belong[i->to])
            Insert(belong[i->from],belong[i->to]);
    }
}

void Tarjan(int root){
    dfn[root]=low[root]=++clk;
    inStack[root]=true;
    s.push(root);
    for(Edge* i=head[root];i!=NULL;i=i->next){
        if(dfn[i->to]==0){
            Tarjan(i->to);
            low[root]=std::min(low[root],low[i->to]);
        }
        else if(inStack[i->to]){
            low[root]=std::min(low[root],dfn[i->to]);
        }
    }
    if(dfn[root]==low[root]){
        scc++;
        int top;
        do{
            top=s.top();
            inStack[top]=false;
            size[scc]++;
            belong[top]=scc;
            s.pop();
        }while(top!=root);
    }
}

void Build(){
    for(int k=1;k<=v;k++){
        if(N[k].type==1){
            std::map< int, std::set<int> >::iterator px=sx.find(N[k].x);
            for(std::set<int>::iterator i=(*px).second.begin();i!=(*px).second.end();++i){
                if(k!=*i)
                    Insert(k,*i);
            }
        }
        else if(N[k].type==2){
            std::map< int, std::set<int> >::iterator py=sy.find(N[k].y);
            for(std::set<int>::iterator i=(*py).second.begin();i!=(*py).second.end();++i){
                if(k!=*i)
                    Insert(k,*i);
            }
        }
        else if(N[k].type==3){
            for(int dx=-1;dx<=1;dx++){
                for(int dy=-1;dy<=1;dy++){
                    if(dx!=0||dy!=0){
                        int tmp=m[N[k].x+dx][N[k].y+dy];
                        if(tmp!=0&&tmp!=k){
                            Insert(k,tmp);
                        }
                    }
                }
            }
        }
    }
}

inline void Insert(int from,int to){
    // printf("Insert %d to %d
",from,to);
    top->from=from;
    top->to=to;
    top->next=head[from];
    head[from]=top++;
}