[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+;
 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=;i<=v;i++){
         if(dfn[i]==)
             Tarjan(i);
     }
     SweepEdge();
     for(int i=;i<=v;i++){
         if(dp[i]==)
             DFS(i);
     }
     printf("%d\n",ans);
     return ;
 }
 
 void Initialize(){
     scanf("%d%d%d",&v,&r,&c);
     for(int i=;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]!=)
         return;
     else{
         dp[root]=size[root];
         int max=;
         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,,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]==){
             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=;k<=v;k++){
         if(N[k].type==){
             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==){
             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==){
             for(int dx=-;dx<=;dx++){
                 for(int dy=-;dy<=;dy++){
                     if(dx!=||dy!=){
                         int tmp=m[N[k].x+dx][N[k].y+dy];
                         if(tmp!=&&tmp!=k){
                             Insert(k,tmp);
                         }
                     }
                 }
             }
         }
     }
 }
 
 inline void Insert(int from,int to){
     // printf("Insert %d to %d\n",from,to);
     top->from=from;
     top->to=to;
     top->next=head[from];
     head[from]=top++;
 }

Backup