codevs 3287 货车运输

题目描述 Description
A 国有 n 座城市,编号从 1 到 n,城市之间有 m 条双向道路。每一条道路对车辆都有重量限制,简称限重。现在有 q 辆货车在运输货物,司机们想知道每辆车在不超过车辆限重的情况下,最多能运多重的货物。

输入描述 Input Description
第一行有两个用一个空格隔开的整数 n,m,表示 A 国有 n 座城市和 m 条道路。
接下来 m 行每行 3 个整数 x、y、z,每两个整数之间用一个空格隔开,表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意:x 不等于 y,两座城市之间可能有多条道路。
接下来一行有一个整数 q,表示有 q 辆货车需要运货。
接下来 q 行,每行两个整数 x、y,之间用一个空格隔开,表示一辆货车需要从 x 城市运输货物到 y 城市,注意:x 不等于 y。

输出描述 Output Description
输出共有 q 行,每行一个整数,表示对于每一辆货车,它的最大载重是多少。如果货车不能到达目的地,输出-1。

样例输入 Sample Input
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

样例输出 Sample Output
3
-1
3

数据范围及提示 Data Size & Hint
对于 30%的数据,0 < n < 1,000,0 < m < 10,000,0 < q < 1,000;
对于 60%的数据,0 < n < 1,000,0 < m < 50,000,0 < q < 1,000;
对于 100%的数据,0 < n < 10,000,0 < m < 50,000,0 < q < 30,000,0 ≤ z ≤ 100,000。

解决思路:首先kruskal构造最大生成树,然后对于树中给定的的两个点,求这两个点之间所连线段中最短的一条。
实现方法:
一(60分)、建一个weight[]数组,weight[x]记录到达节点x的一路上经过的所有边中最短的一条。对于每一次询问,在最大生成树中跑一边SPFA,更新weight[i]的值(有点类似于dp的思想)。
然而还有一个问题,由于树的边是无向的(双向的),当点x更新完y后,y会反过来更新x,这样导致的问题是每个点的weight值都为最小边的长度了,所以开一个bool visited[] 数组让每个点只走一遍就好了(看起来像是废话,但确实是我这个蒟蒻犯过的错误)。
但是会TLE三个点。
代码如下:

#include
#include
#include
#include
using namespace std;

bool b[10010],visited[10010];//visited每个点只走一遍 
int n,m,x,y,z,q,x1,yy,num_edge1,num_edge2,head[10010],father[10010],weight[10010];//weight[] 到达该城市的最大限重 
struct Edge1{
    int next,to,dis;
};
Edge1 edge1[50010];

struct Edge2{//Kruskal's edge
    int from,to,value;
};
Edge2 edge2[50010];

void add_edge1(int from,int to,int dis)//存最大生成树的图 
{
    edge1[++num_edge1].next=head[from];
    edge1[num_edge1].to=to;
    edge1[num_edge1].dis=dis;
    head[from]=num_edge1;
}

void add_edge2(int from,int to,int value)//Kruskal's graph
{
    edge2[++num_edge2].from=from;
    edge2[num_edge2].to=to;
    edge2[num_edge2].value=value;
}

int find(int x)
{
    if (father[x]!=x) return father[x]=find(father[x]);
    return father[x];
}

void unionn(int x,int y)
{
    int xx=find(x);
    int yy=find(y);
    if (xx!=yy) father[xx]=yy;
}

bool comp(Edge2 a,Edge2 b)
{
    return a.value>b.value;//最大生成树 
}

void SPFA(int s,int t)
{
    queue<int> q;
    memset(b,false,sizeof(b));
    memset(visited,false,sizeof(visited));
    memset(weight,0x7f,sizeof(weight)); //初始化为极大值 
    q.push(s); b[s]=true;  //weight[s]=0;
    do
    {
        int now=q.front();
        q.pop(); b[now]=false; visited[now]=true;

        for (int i=head[now]; i!=0; i=edge1[i].next)
            if (!visited[edge1[i].to]&&weight[edge1[i].to]>min(edge1[i].dis,weight[now]))//错误:if (weight[edge1[i].to]>edge1[i].dis)
            {
                visited[edge1[i].to]=true;
                weight[edge1[i].to]=min(edge1[i].dis,weight[now]);//动态规划的思想 
                if (!b[edge1[i].to])
                {
                    b[edge1[i].to]=true;
                    q.push(edge1[i].to);
                }
            }
    }
    while(!q.empty());
    if (weight[t]==0x7f7f7f7f) printf("-1\n");
    else printf("%d\n",weight[t]);
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
        father[i]=i;
    for (int i=1; i<=m; i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        add_edge2(x,y,z);
    }
    sort(edge2+1,edge2+1+m,comp);
    for (int i=1; i<=m; i++)
    {
        if (find(edge2[i].from)!=find(edge2[i].to))
        {
            unionn(edge2[i].from,edge2[i].to);
            add_edge1(edge2[i].from,edge2[i].to,edge2[i].value);//构造最大生成树 
            add_edge1(edge2[i].to,edge2[i].from,edge2[i].value);//无向图 
        }
    }
    scanf("%d",&q);
    for (int i=1; i<=q; i++)
    {
        scanf("%d%d",&x1,&yy);
        SPFA(x1,yy);
    }
    return 0;
}

二(100分)、查询两点之间的线段,很容易想到LCA(最近公共祖先)。
先进行一遍dfs记忆化搜索(可以说记忆化搜索的本质是动态规划:最优化原理和后无效性),用来初始化每一个点的信息。然后lca板子,一个ask函数,查询一点到祖先的最小线段。最后取x和y中ask中的较小值就AC了。
代码如下:

#include
#include
#include
#include
using namespace std;

bool b[10010],visited[10010];//visited每个点只走一遍 
int n,m,x,y,z,q,num_edge1,num_edge2,head[10010],deep[10010],father[10010],fa[10010][17],dis[10010][17];
//fa[x][i]:x节点向上跳2^i的节点,fa[x][0]:x节点的父节点;dis[x][i]:节点x向上跳2^i的路径中的最小边权 
struct Edge1{
    int next,to,dis;
};
Edge1 edge1[50010];

struct Edge2{//Kruskal's edge
    int from,to,value;
};
Edge2 edge2[50010];

void add_edge1(int from,int to,int dis)//存最大生成树的图 
{
    edge1[++num_edge1].next=head[from];
    edge1[num_edge1].to=to;
    edge1[num_edge1].dis=dis;
    head[from]=num_edge1;
}

void add_edge2(int from,int to,int value)//Kruskal's graph
{
    edge2[++num_edge2].from=from;
    edge2[num_edge2].to=to;
    edge2[num_edge2].value=value;
}

int find(int x)
{
    if (father[x]!=x) return father[x]=find(father[x]);
    return father[x];
}

void unionn(int x,int y)
{
    int xx=find(x);
    int yy=find(y);
    if (xx!=yy) father[xx]=yy;
}

bool comp(Edge2 a,Edge2 b)
{
    return a.value>b.value;//最大生成树 
}

void dfs(int x)//记忆化搜索,保存每一个点的 deep[] fa[][] dis[][],在后面用到 
{
    visited[x]=1;
    for (int i=1; i<=16; i++)//初始化 
    { //2^16=65536>50000
        if ((1<deep[x]) break;//1< 2^i
        fa[x][i]=fa[fa[x][i-1]][i-1];//(2^j-1)+(2^j-1)=2^j
        dis[x][i]=min(dis[x][i-1],dis[fa[x][i-1]][i-1]);//错误:dis[x][i]=dis[fa[x][i-1]][i-1],应该为较小值啊啊啊 
    }
    for (int i=head[x]; i!=0; i=edge1[i].next)
    {//更新3点 
        if (!visited[edge1[i].to])//必须没走过,漏了这一点 !!
        {
            deep[edge1[i].to]=deep[x]+1;
            fa[edge1[i].to][0]=x;//存父节点 
            dis[edge1[i].to][0]=edge1[i].dis;//将dis[j][0]存指向j点的边的权值 
            dfs(edge1[i].to);//不需要回溯 
        }
    }
}

int lca(int x,int y)//求最近公共祖先 
{
    if (deep[x]//交换下标 
    int d=deep[x]-deep[y];//深度差 
    for (int i=0; i<=16; i++)//倒?正? 
    {//从0开始是为了x与y深度一样的情况 
        if ((1<//使x跳到与y深度相等的地方(d为深度差) 
    }
    for (int i=16; i>=0; i--)//因为要找最深的公共祖先,所以要倒着找 
        if (fa[x][i]!=fa[y][i])
        {//找祖宗的祖宗 
            x=fa[x][i];//x和y一起向上跳 
            y=fa[y][i];
        }
    if (x==y) return x;//x和y重合的情况 
    return fa[x][0];//如果x和y不重合,x和y就有同一个爹 
}

int ask(int x,int k)//查询一点到祖先的最小线段 
{
    int minn=0x7fffffff;
    int d=deep[x]-deep[k];//到祖先的距离 
    for (int i=16; i >= 0; i--)
        if ((1<//向上跳 
            d -= (1 << i);
        }
    return minn;
}

int main()
{
    memset(dis,0x7f/3,sizeof(dis));//不初始化会有大问题 
    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
        father[i]=i;
    for (int i=1; i<=m; i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        add_edge2(x,y,z);
    }
    sort(edge2+1,edge2+1+m,comp);
    int k=0;
    for (int i=1; i<=m; i++)
    {
        if (find(edge2[i].from)!=find(edge2[i].to))
        {
            unionn(edge2[i].from,edge2[i].to);
            add_edge1(edge2[i].from,edge2[i].to,edge2[i].value);//构造最大生成树 
            add_edge1(edge2[i].to,edge2[i].from,edge2[i].value);//无向图 
            k++;
            if (k==n-1) break;
        }
    }
    for (int i=1; i<=n; i++)
        if (!visited[i]) dfs(i);
    scanf("%d",&q);
    for (int i=1; i<=q; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if (find(x)!=find(y)) printf("-1\n");//不在一个并查集里面.这种处理方法比==0x7f7f7f7f printf -1 好 
        else
        {
            int grandfather=lca(x,y);//祖先 
            printf("%d\n",min(ask(x,grandfather),ask(y,grandfather)));
        }
    }
    return 0;
}

总结:本题的关键之处在于想到构造最大生成树,用lca倍增进行优化。有的时候生成树并不是问题的全部,而只是解决问题的一部分。

你可能感兴趣的:(图论及其应用,lca倍增,生成树,图论,生成树,lca)