hdu 4338 Simple Path

原創 shiqi_614 2020-07-02 17:12

題意：有N個點，M條邊，下面M行給出M條邊後，有Q個詢問，給你兩個點，起點s，終點t，問從起點s到終點t的簡單路徑中（簡單路徑沒有環），不包括圖中的哪些點，如果s和t重合，那麼就輸出N-1，如果s無法到達t，輸出N，否則輸出路徑中不包括的點的個數。

用點雙連通分量建圖（割點可以在不同的塊中），然後求LCA。

比如對於這樣的圖：



拿割點和點雙連通分量建圖後：


紅色的對應的就是割點，黑色的是點連通分量， 當求(1,7)時候，我們分別查看1,7對應所在樹中的集合，求出路徑上所有的和 sum = 2 + 1 + 3 + 1 +3 + 1 + 2 = 13，由於割點被重複計算，計算的次數爲樹邊的數量。

len = 6 ， ans = sum - len = 7 ,答案就是可能停留的有7個點。

然後就是如何實現如上問題。

如上圖，求1,2的最短距離即爲lca（1,2），而結果就是，定義樹根到某點路徑所有的長度爲son[i],nb[i]爲集合中樹節點中元素個數

sum = son[1]+son[2]-2*son[3]+bn[3]

len = deep[1]+deep[2]-2*deep[3]


1.首先是用倍增法求LCA，因爲會棧溢出所以手寫了棧。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
using namespace std;
const int N=200005;
#define Log 22
struct Edge
{
    int v;
    Edge *nxt;
}memo[N*10],*cur,*h_bef[N],*h_aft[N];
void addEdge(int u,int v,Edge* head[])
{
    cur->v=v; cur->nxt=head[u];
    head[u]=cur++;
}
int bnum,bn[N];			//有多少個點雙連通分量，每個分量有多少個點。
vector<int> block[N];	//保存每個點雙連通分量
bool iscut[N];			//是否是割點

bool vis[N];
stack<int> stk;			//tarjan用到的
int dfn[N],low[N],son_root,idx;

int lab[N];				//重新建圖後每個點的編號
int id[N];				//重新建圖後每個點在哪棵樹內
int son[N];				//從當前點到其子樹根結點有多少個結點
int fa[N];				//存儲手寫棧的過程中子結點是什麼狀態

int dp[N][Log],dep[N];	//倍增法求LCA

void tarjan(int pt_u,int pt_pre)//手寫棧版tarjan
{
    stack<int> stk_tar;
    stk_tar.push(pt_u);    fa[pt_u]=pt_pre;

    while(stk_tar.size())
    {
        int u=stk_tar.top();
        int pre=fa[u];

        if(dfn[u]==0) dfn[u]=low[u]=++idx,stk.push(u);

        Edge* it;
        for(it=h_bef[u];it;it=it->nxt)
        {
            int v=it->v;
            if(v==pre) continue;

            if(fa[v]==-1)
            {
                fa[v]=u;  stk_tar.push(v);
                h_bef[u]=it;
                break;
            }
            else
            {
                if(fa[v]==u)
                {
                    low[u]=min(low[u],low[v]);

                    if(dfn[u]<=low[v])
                    {
                        if(pre==-2) son_root++;
                        else iscut[u]=1;

                        while(1)
                        {
                            int top=stk.top(); stk.pop();
                            block[bnum].push_back(top);
                            if(top==v) break;
                        }
                        block[bnum].push_back(u);
                        bnum++;
                    }
                }

                else low[u]=min(low[u],dfn[v]);
            }
        }
        if(it==NULL) stk_tar.pop();
    }
}
void dfs(int pt_u,int pt_pre,int iid)//手寫棧dfs，將在一個塊內的點染成一個顏色，得到用倍增法求LCA的信息。
{
    stack<int> stk_dfs;
    stk_dfs.push(pt_u);    fa[pt_u]=pt_pre;

    while(stk_dfs.size())
    {
        int u=stk_dfs.top();
        int pre=fa[u];

        if(dep[u]==0)
        {
            dep[u]=dep[ dp[u][0] ]+1;
            for(int i=1;i<Log;i++) dp[u][i]=dp[ dp[u][i-1] ][ i-1 ];

            id[u]=iid;    son[u]=(pre==-1?0:son[pre])+bn[u];
        }

        Edge* it;
        for(it=h_aft[u];it;it=it->nxt)
        {
            int v=it->v;
            if(v==pre) continue;

            dp[v][0]=u; fa[v]=u;
            stk_dfs.push(v);
            h_aft[u]=it->nxt;
            break;
        }
        if(it==NULL) stk_dfs.pop();
    }
}
int lca(int u,int v)//倍增法求LCA
{
    if(dep[u]<dep[v]) swap(u,v);
    for(int st=(1<<(Log-1)),i=Log-1;i>=0;st>>=1,i--)
    {
        if(st<=dep[u]-dep[v])
        {
            u=dp[u][i];
        }
    }

    if(u==v) return u;

    for(int i=Log-1;i>=0;i--)
    {
        if(dp[u][i]!=dp[v][i])
        {
            u=dp[u][i];
            v=dp[v][i];
        }
    }
    return dp[u][0];
}
void init()
{
    cur=memo;
    memset(h_bef,0,sizeof(h_bef));
    memset(h_aft,0,sizeof(h_aft));
    memset(dp,0,sizeof(dp));

    bnum=0; idx=0;    son_root=0;
    while(stk.size()) stk.pop();
    for(int i=0;i<N;i++)
    {
        block[i].clear();
        dfn[i]=0;    low[i]=0;    lab[i]=-1;
        id[i]=i;    iscut[i]=0;    bn[i]=0;
        son[i]=0;    dep[i]=0;      vis[i]=0;
        fa[i]=-1;
    }
}
int main()
{
    int n,m,Q,t_cnt=0;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();

        for(int i=0;i<m;i++)
        {
            int u,v; scanf("%d%d",&u,&v);
            addEdge(u,v,h_bef);
            addEdge(v,u,h_bef);
        }

        for(int i=0;i<n;i++) if(dfn[i]==0)
        {
            son_root=0;
            tarjan(i,-2);
            if(son_root>1) iscut[i]=1;
        }

        int k=0;
        for(int i=0;i<n;i++) if(iscut[i])
        {
            lab[i]=k; bn[k]=1; k++;
        }

        for(int i=0;i<bnum;i++)
        {
            for(int j=0;j<(int)block[i].size();j++)
            {
                int u=block[i][j];
                if(iscut[u])					//利用割點重新建圖
                {
                    addEdge(lab[u],k,h_aft);
                    addEdge(k,lab[u],h_aft);
                }
                else lab[u]=k;
            }
            bn[k]=(int)block[i].size();
            k++;
        }

        memset(fa,-1,sizeof(fa));
        for(int i=0;i<k;i++) if(dep[i]==0) dfs(i,-1,i);

        scanf("%d",&Q);

        printf("Case #%d:\n",++t_cnt);
        while(Q--)
        {
            int s,t; scanf("%d%d",&s,&t);
            if(s==t) printf("%d\n",n-1);
            else if(lab[s]==-1||lab[t]==-1||id[lab[s]]!=id[lab[t]]) printf("%d\n",n);
            else
            {
                s=lab[s]; t=lab[t];
                int parent=lca(s,t);
                int cnt=son[s]+son[t]-2*son[parent]+bn[parent];
                int len=dep[s]+dep[t]-2*dep[parent];
                int ans=cnt-len;
                printf("%d\n",n-ans);
            }
        }
        puts("");
    }
    return 0;
}

2.非手寫棧，倍增法求LCA（就只是在代碼最開始處加了一行） 

#pragma comment(linker, "/STACK:102400000,102400000")

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <stack>
using namespace std;
const int N=200005;
#define Log 22
struct Edge
{
    int v;
    Edge *nxt;
}memo[N*10],*cur,*h_bef[N],*h_aft[N];
void addEdge(int u,int v,Edge* head[])
{
    cur->v=v; cur->nxt=head[u];
    head[u]=cur++;
}
int bnum,bn[N];
vector<int> block[N];
bool iscut[N];

bool vis[N];
stack<int> stk;
int dfn[N],low[N],son_root,idx;

int lab[N],id[N],son[N],fa[N];

int dp[N][Log],dep[N];

void tarjan(int pt_u,int pt_pre)
{
    stack<int> stk_tar;
    stk_tar.push(pt_u);    fa[pt_u]=pt_pre;

    while(stk_tar.size())
    {
        int u=stk_tar.top();
        int pre=fa[u];

        if(dfn[u]==0) dfn[u]=low[u]=++idx,stk.push(u);

        Edge* it;
        for(it=h_bef[u];it;it=it->nxt)
        {
            int v=it->v;
            if(v==pre) continue;

            if(fa[v]==-1)
            {
                fa[v]=u;  stk_tar.push(v);
                h_bef[u]=it;
                break;
            }
            else
            {
                if(fa[v]==u)
                {
                    low[u]=min(low[u],low[v]);

                    if(dfn[u]<=low[v])
                    {
                        if(pre==-1) son_root++;
                        else iscut[u]=1;

                        while(1)
                        {
                            int top=stk.top(); stk.pop();
                            block[bnum].push_back(top);
                            if(top==v) break;
                        }
                        block[bnum].push_back(u);
                        bnum++;
                    }
                }

                else low[u]=min(low[u],dfn[v]);
            }
        }
        if(it==NULL) stk_tar.pop();
    }

}
void dfs(int u,int pre,int cnt,int iid)
{
    dep[u]=dep[ dp[u][0] ]+1;
    for(int i=1;i<Log;i++) dp[u][i]= dp[ dp[u][i-1] ][ i-1 ];

    id[u]=iid;    son[u]=cnt+bn[u];
    for(Edge* it=h_aft[u];it;it=it->nxt)
    {
        int v=it->v;
        if(v!=pre)
        {
            dp[v][0]=u;
            dfs(v,u,son[u],iid);
        }
    }
}
int lca(int u,int v)
{
    if(dep[u]<dep[v]) swap(u,v);
    for(int st=(1<<(Log-1)),i=Log-1;i>=0;st>>=1,i--)
    {
        if(st<=dep[u]-dep[v])
        {
            u=dp[u][i];
        }
    }

    if(u==v) return u;

    for(int i=Log-1;i>=0;i--)
    {
        if(dp[u][i]!=dp[v][i])
        {
            u=dp[u][i];
            v=dp[v][i];
        }
    }
    return dp[u][0];
}
void init()
{
    cur=memo;
    memset(h_bef,0,sizeof(h_bef));
    memset(h_aft,0,sizeof(h_aft));
    memset(dp,0,sizeof(dp));

    bnum=0; idx=0;    son_root=0;
    while(stk.size()) stk.pop();
    for(int i=0;i<N;i++)
    {
        block[i].clear();
        dfn[i]=0;    low[i]=0;    lab[i]=-1;
        id[i]=i;    iscut[i]=0;    bn[i]=0;
        son[i]=0;    dep[i]=0;      vis[i]=0;
        fa[i]=-1;
    }
}
int main()
{
    int n,m,Q,t_cnt=0;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();

        for(int i=0;i<m;i++)
        {
            int u,v; scanf("%d%d",&u,&v);
            addEdge(u,v,h_bef);
            addEdge(v,u,h_bef);
        }

        for(int i=0;i<n;i++) if(dfn[i]==0)
        {
            son_root=0;
            tarjan(i,-2);
            if(son_root>1) iscut[i]=1;
        }

        int k=0;
        for(int i=0;i<n;i++) if(iscut[i])
        {
            lab[i]=k; bn[k]=1; k++;
        }

        for(int i=0;i<bnum;i++)
        {
            for(int j=0;j<(int)block[i].size();j++)
            {
                int u=block[i][j];
                if(iscut[u])
                {
                    addEdge(lab[u],k,h_aft);
                    addEdge(k,lab[u],h_aft);
                }
                else lab[u]=k;
            }
            bn[k]=(int)block[i].size();
            k++;
        }

        for(int i=0;i<k;i++) if(dep[i]==0) dfs(i,-1,0,i);

        scanf("%d",&Q);

        printf("Case #%d:\n",++t_cnt);
        while(Q--)
        {
            int s,t; scanf("%d%d",&s,&t);
            if(s==t) printf("%d\n",n-1);
            else if(lab[s]==-1||lab[t]==-1||id[lab[s]]!=id[lab[t]]) printf("%d\n",n);
            else
            {
                s=lab[s]; t=lab[t];
                int parent=lca(s,t);
                int cnt=son[s]+son[t]-2*son[parent]+bn[parent];
                int len=dep[s]+dep[t]-2*dep[parent];
                int ans=cnt-len;
                printf("%d\n",n-ans);
            }
        }
        puts("");
    }
    return 0;
}


3.非手寫棧，求LCA轉化成RMQ。
#pragma comment(linker, "/STACK:102400000,102400000")

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
using namespace std;

#define N 200005
struct Edge
{
    int v;
    Edge* nxt;
}memo[N*10],*cur,*h_bef[N],*h_aft[N];
void addEdge(int u,int v,Edge* head[])
{
    cur->v=v; cur->nxt=head[u];
    head[u]=cur++;
}

stack<int> stk;
int dfn[N],low[N],iscut[N];
int idx,son_root;

int bnum;
vector <int> block[N];

int lab[N],bn[N];

int dp[N*2][20];
int dpid[N*2][20];
int dep[N*2],pos[N*2],fa[N*2],son[N*2],ihash[N*2];

void tarjan(int u,int pre)
{
    stk.push(u);
    dfn[u]=low[u]=++idx;
    for(Edge* it=h_bef[u];it;it=it->nxt)
    {
        int v=it->v;
        if(v==pre) continue;
        
        if(dfn[v]==-1)
        {
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(low[v]>=dfn[u])
            {
                if(pre == -1)son_root++;
                else iscut[u]=1;
                   while(1) 
                {
                    int top=stk.top(); stk.pop();
                    block[bnum].push_back(top);
                    if(top==v) break;
                }
                block[bnum].push_back(u);
                bnum++;
            }
        }
        else low[u]=min(low[u],dfn[v]);
    }
}


void Create_ST(int len)
{
    for(int i=0;i<len;i++)
    {
        dp[i][0]=i;
    }
    for(int j=1;(1<<j)<=len; j++ )
        for(int i=0;i+(1<<j)-1<len;i++)
            if(dep[ dp[i][j-1] ]<dep[ dp[i+(1<<(j-1))][j-1] ])
            {
                dp[i][j] = dp[i][j-1] ;
            }
            else
            {
                dp[i][j] = dp[i+(1<<(j-1))][j-1];
            }
}
int lca(int a,int b)
{
    if(pos[a]>pos[b]) swap(a,b);
    a=pos[a]; b=pos[b];
    int k = (int)(log((double)(b*1.0-a+1))/log(2.0));

    int tmp1=a,tmp2=b-(1<<k)+1;
    if(dep[ dp[tmp1][k] ]<dep[ dp[tmp2][k] ]) return ihash[dp[tmp1][k]];
    else return ihash[dp[tmp2][k]];
}
void dfs(int u,int pre,int d,int cnt,int id)
{
    if(pos[u]==-1)
    {
        pos[u]=idx;
        fa[u]=id;
    }
    ihash[idx]=u;
    dep[idx++]=d;
    son[u]=cnt+bn[u];
    for(Edge* it=h_aft[u];it;it=it->nxt)
    {
        int v=it->v;
        if(v==pre)continue;

        dfs(v,u,d+1,son[u],id);
        ihash[idx]=u;
        dep[idx++]=d;
    }
}
void init()
{
    cur=memo;
    memset(h_bef,0,sizeof(h_bef));
    memset(h_aft,0,sizeof(h_aft));
    
    for(int i=0;i<N;i++) block[i].clear();
    while(stk.size()) stk.pop();    

    memset(lab,-1,sizeof(lab));
    memset(iscut,0,sizeof(iscut));
    memset(dfn,-1,sizeof(dfn));
    idx=bnum=0;

    memset(pos,-1,sizeof(pos));
}
int main()
{
    int n,m,Q,t_cnt=0;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        
        for(int i=0;i<m;i++)
        {
            int u,v;    scanf("%d%d",&u,&v);
            addEdge(u,v,h_bef);
            addEdge(v,u,h_bef);
        }

        for(int i=0;i<n;i++) if(dfn[i]==-1)
        {
            son_root=0;
            tarjan(i,-1);
            iscut[i]=(son_root>1);
        }
        
        int k=0;
        for(int i=0;i<n;i++) if(iscut[i])
        {
            lab[i]=k; bn[k]=1; k++;
        }
        for(int i=0;i<bnum;i++)
        {
            for(int j=0;j<(int)block[i].size();j++)
            {
                int u=block[i][j];
                if(iscut[u])
                {
                    addEdge(lab[u],k,h_aft);
                    addEdge(k,lab[u],h_aft);
                }
                else
                {
                    lab[u]=k;
                }
            }
            bn[k]=int(block[i].size()); k++;
        }
        
        idx=0;
        for(int i=0;i<k;i++) if(pos[i]==-1) dfs(i,-1,0,0,i);
        
        Create_ST(idx);

        printf("Case #%d:\n",++t_cnt);
        scanf("%d",&Q);
        while(Q--)
        {
            int s,t;    scanf("%d%d",&s,&t);
            if(s==t) printf("%d\n",n-1);
            else if(lab[s]==-1 || lab[t]==-1 || fa[lab[s]] != fa[lab[t]]) printf("%d\n",n);
			else 
			{
				int u = lab[s]; 
				int v = lab[t];
				int father=lca(u,v); 
				int ans=son[u]+son[v]-2*son[father]+bn[father];
				int len=dep[pos[u]]+dep[pos[v]]-2*dep[pos[father]];
				ans -= len;
				printf("%d\n",n-ans);
			}
        }
        puts("");
    }
    return 0;
}



發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Leetcode - 圖（一）

997. 找到小鎮的法官 https://leetcode-cn.com/problems/find-the-town-judge/ 在一個小鎮裏，按從 1 到 N 標記了 N 個人。傳言稱，這些人中有一個是小鎮上的祕密法官。如果小鎮的法

一杯敬朝阳一杯敬月光 2020-07-07 02:12:58

hdu 4324 Triangle LOVE (targan判連通)

題目鏈接：http://acm.hdu.edu.cn/showproblem.php?pid=4324 這題也是比較裸的題， 判斷是否存在超過三個節點的強連通分量，由於題目說不存在兩個節點的強連通分量。直接統計連通分量，如果總數小於初

Algobird 2020-07-08 10:04:45

poj 2762 Going from u to v or from v to u（targan縮點+拓撲排序）

題目鏈接：http://poj.org/problem?id=2762 給定頂點和邊的關係，問是否對於任意的頂點x和y,總存在x到y的路徑或y到x的路徑，一開始看成和的關係，判斷只有一個連通分量。 如果是或的話，就是對於縮點後的圖看看能不

Algobird 2020-07-08 10:04:45

poj 3249 Test for Job (拓撲排序)

題目鏈接：http://poj.org/problem?id=3249 給出每個點的價值以及有向邊，然後求所有路徑中，價值和最大的路徑，問最大價值爲多少。 路徑要求從入度爲0的點出發，出度爲0的點停止，價值可能爲負值。 直接用拓撲排序，

Algobird 2020-07-08 10:04:45

hdu 1269 迷宮城堡（tarjan判連通）

題目鏈接：http://acm.hdu.edu.cn/showproblem.php?pid=1269 本題是判斷連通分量個數是否爲1，裸題。 代碼： #include <cstdio> #include <algorithm> #inc

Algobird 2020-07-08 10:04:45

DFS和BFS遍歷

int n; //結點個數 int mp[N][N]; //鄰接矩陣 int vis[N]; //記錄此頂點是否遍歷過； DFS void DFS(int x) { int i; countt++

_Crazy€ 2020-07-07 04:10:54

判斷給定圖是否存在合法拓撲序列

數據結構實驗之圖論十：判斷給定圖是否存在合法拓撲序列 Problem Description 給定一個有向圖，判斷該有向圖是否存在一個合法的拓撲序列。 Input 輸入包含多組，每組格式如下。 第一行包含兩個整數n，m，分別代表該

_Crazy€ 2020-07-07 04:10:54

數據結構——最小生成樹（C語言）

數據結構實驗之圖論九：最小生成樹 Problem Description 有n個城市，其中有些城市之間可以修建公路，修建不同的公路費用是不同的。現在我們想知道，最少花多少錢修公路可以將所有的城市連在一起，使在任意一城市出發，可以到

_Crazy€ 2020-07-07 04:10:54

Network of Schools POJ1236(tarjan縮點+強連通分量模板)

Network of Schools Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 19564   Accepted: 7705 Description

丶先森 2020-07-07 01:09:36

【圖論】割點、橋、雙連通

連通分量 個數可以通過一次BFS或者DFS得到 割點和橋 可以枚舉刪除每一個點或者每一條邊，判斷連通分量個數是否增加 更好的方法 該算法是R.Tarjan發明的。對圖深度優先搜索，定義DFS(u)爲u在搜索樹（以下簡稱爲樹）中被遍歷

abgnwl 2020-07-07 00:28:44

圖的邊表存儲結構及其上的Kruskal算法實現；

如題；這是一套完整的可運行的代碼；需要讀者有一定的基礎去閱讀； 語言是用C語言實現；在C++環境中編寫；在C++中可直接運行；在C語言中需要改部分頭文件和輸出語句； 頭文件；這要是代碼的聲明部分； # ifndef _ELGRAPH_

Alan Qin 2020-07-06 19:06:02

有向圖的十字鏈表存儲；

如題；這是一套完整的可運行的代碼；需要讀者有一定的基礎去閱讀； 語言是用C語言實現；在C++環境中編寫；在C++中可直接運行；在C語言中需要改部分頭文件和輸出語句； 頭文件；這要是代碼的聲明部分； # ifndef _OLGRAPH_

Alan Qin 2020-07-06 19:06:01

一圖搞定MySQL體系架構

要了解mysql的運行機制，那麼首先要對mysql的體系結構有一定的瞭解。 最近由於一些事，被打擊的不輕，感覺自己可能再怎麼努力，職業生涯也就這樣了。所以對專研技術、寫博客突然喪失了原來的激情。 但不管怎樣，路是自己選的，哭着

斗者_2013 2020-07-06 07:38:53

第十二週項目1-驗證算法（5）

/* *Copyright (c) 2017,煙臺大學計算機與控制工程學院 *All rights reserved. *文件名稱：項目1-拓撲排序算法的驗證

sunshine1119213 2020-07-06 05:05:59

百練1473:There's Treasure Everywhere!

題目鏈接：點擊打開鏈接 代碼： #include<cstdio> #include<cstring> #include<cmath> #include<cctype> using namespace std; const int N =

beimeng321 2020-07-06 03:57:08