7.8练习赛

7.8练习赛

A修公路

时间限制 : - MS   空间限制 : 65536 KB 

评测说明 : 时限1000ms

 

问题描述

某岛国有n个小岛构成(编号1到n)，该国政府想要通过n-1条双向公路将这些小岛连接起来，使得任意两个岛屿之间都能相互到达。公路有两种，一种是高速公路，车速快，建设花费大；另一种是普通公路，车速慢，建设花费少。该国政府不想在一条公路上花费过多的钱，但又要求修建的公路中至少有k条高速公路。所以政府希望，在满足上述条件的情况下，使得最贵的一条公路花费尽可能少，请你帮忙计算出其中最贵一条公路的价格。

输入格式

第一行，三空格间隔的整数n,k,m，其中m表示有m对岛屿间可以修路。
     接下来以下的m行，每行四个正整数a,b,c1,c2 表示在岛屿a与b 之间修高速公路花费c1块钱,修普通公路,花费c2块钱。

输出格式

一个整数表示最贵那条公路的费用。

样例输入 1

4 2 4
1 2 6 5
1 3 3 1
2 4 6 1
3 4 4 2

样例输出 1

4

样例输入 2

4 1 5
1 2 6 5
1 3 3 1
2 3 9 4
2 4 6 1
3 4 4 3

样例输出 2

3

样例输入 3

10 4 19
3 9 6 3
1 3 4 1
5 3 10 2
8 9 8 7
6 8 8 3
7 1 3 2
4 9 9 5
10 8 9 1
2 6 9 1
6 7 9 8
2 6 2 1
3 8 9 5
3 2 9 6
1 6 10 3
5 6 3 1
2 7 6 1
7 8 6 2
10 9 2 1
7 1 10 2

样例输出 3

5

提示

对于30%的数据， 1<=n<=1000           0<=k<=10             n-1<=m<=3000

对于100%的数据，1<=n<=10000          0<=k<=n-1            n-1<=m<=20000

二分答案+最少生成树思想
二分生成树的最大边权mid，判断这样的生成树是否存在就行了

每次判断时分成两步走，首先讨论高速公路，选用的高速公路边权小于等于mid，能加的边都加进去
判断生成树中的树边个数是否小于等于k，若小于k，表明这个生成树不存在。

再讨论普通公路，能加进去的边都加进去，加完边后判断生成树的树边是不是n-1
（生成树联通了所有的点），若不是，表明这个生成树不存在。

老板代码

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x;
}
int n,K,m,ans;
int fa[10005];
struct data{int x,y,c1,c2;}e[20005];
int find(int x)
{return x==fa[x]?x:fa[x]=find(fa[x]);}
bool jud(int x)
{
    for(int i=1;i<=n;i++)fa[i]=i;
    int cnt=0;
    for(int i=1;i<=m;i++)
    {
        if(e[i].c1>x)continue;
        int p=find(e[i].x),q=find(e[i].y);
        if(p!=q)
        {fa[p]=q;cnt++;}
    }
    if(cnt<K)return 0;
    for(int i=1;i<=m;i++)
    {
        if(e[i].c2>x)continue;
        int p=find(e[i].x),q=find(e[i].y);
        if(p!=q)
        {fa[p]=q;cnt++;}
    }
    if(cnt!=n-1)return 0;
    return 1;
}
int main()
{
    freopen("road.in","r",stdin);
    freopen("road.out","w",stdout);
    n=read(),K=read(),m=read();
    for(int i=1;i<=m;i++)
        e[i].x=read(),e[i].y=read(),e[i].c1=read(),e[i].c2=read();
    int l=1,r=30000;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(jud(mid)){ans=mid;r=mid-1;}
        else {l=mid+1;}
    }
    printf("%d",ans);
    return 0;
}

自己的：

#include<stdio.h>
#include<bits/stdc++.h>
using namespace std;
int father[10005];
struct ztcakioi
{
    int a,b,gao,pu;
};
int n,k,m,L=1,R=2000005,mid;
ztcakioi edge[20005];
int read()
{
    int x=0;
    char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9')
    {
        x=(x<<1)+(x<<3)+c-'0';
        c=getchar();
    }
    return x;
}
int getfather(int p)
{
    if(father[p]!=p)father[p]=getfather(father[p]);
    return father[p];
}
bool Kruskal(int ans)
{
    int i,x,y,cnt=0;
    for(int i=1; i<=n; i++)father[i]=i;
    for(int i=1; i<=m&&cnt<n-1; i++)
    {
        if(edge[i].gao>ans)continue; //超过ztcakioi二分结果，返回 
        x=edge[i].a;
        y=edge[i].b;
        x=getfather(x);
        y=getfather(y);
        if(x==y)continue;
        father[x]=y;
        cnt++;//ztcakioi 次数+1 
    }
    if(cnt<k)return false;//ztcakioi次数不合条要求 ，返回 
    for(int i=1; i<=m&&cnt<n-1; i++)
    {
        if(edge[i].pu>ans)continue;//超过ztcakioi二分结果，返回 
        x=edge[i].a;
        y=edge[i].b;
        x=getfather(x);
        y=getfather(y);
        if(x==y)continue;
        father[x]=y;
        cnt++;
    }
    if(cnt==n-1)return true;//ztcak了全部赛事 
    return false;
}
int main()
{
    ios::sync_with_stdio(false);
    cout.tie(NULL);
    n=read(),k=read(),m=read();
    for(int i=1; i<=m; i++)
    {
        edge[i].a=read(),edge[i].b=read(),edge[i].gao=read(),edge[i].pu=read();
    }
    while(L<=R)//二分
    {
        mid=(L+R)/2;
        if(Kruskal(mid))R=mid-1;
        else L=mid+1;
    }
    cout<<L;
}

B【USACO 2015 Jan Gold】牧草鉴赏家

时间限制 : 10000 MS   空间限制 : 65536 KB

问题描述

约翰有n块草场，编号1到n，这些草场由若干条单行道相连。奶牛贝西是美味牧草的鉴赏家，她想到达尽可能多的草场去品尝牧草。

贝西总是从1号草场出发，最后回到1号草场。她想经过尽可能多的草场，贝西在通一个草场只吃一次草，所以一个草场可以经过多次。因为草场是单行道连接，这给贝西的品鉴工作带来了很大的不便，贝西想偷偷逆向行走一次，但最多只能有一次逆行。问，贝西最多能吃到多少个草场的牧草。

输入格式

第一行，两个整数N和M(1<=N,M<=100000)
接下来M行，表示有M条单向道路，每条道路有连个整数X和Y表示，从X出发到达Y。

输出格式

一个整数，表示所求答案

样例输入

7 10
1 2
3 1
2 5
2 4
3 7
3 5
3 6
6 5
7 2
4 7

样例输出

6

提示

贝西的行走线路是1, 2, 4, 7, 2, 5, 3, 1 ，在5到3的时候逆行了一次。

题意：

给一个有向图，然后选一条路径起点终点都为1的路径出来，有一次机会可以沿某条边逆方向走，
问最多有多少个点可以被经过？（一个点在路径中无论出现多少次(≥1)对答案的贡献均为1）

题解：

首先强连通分量缩点。
然后形成了dfs统计出：
集合A：点 1 能到哪些点,
集合B：哪些点能到点 1
然后这两个集合各为拓扑图。
现在一条从1出发，最后又回到1的最长路径就可以被表示为
1~A中某点a最长链+此点通过逆向边直接回到集合B中某点b后1~b的最长链。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#define N 200003
using namespace std;
int n,m;
int point[N],v[N],Next[N],x[N],y[N],dis[N],dis1[N],can[N];
int belong[N],size[N],st[N],top,tot,cnt,sz,dfsn[N],ins[N],low[N];
void add(int x,int y)
{
    tot++;
    Next[tot]=point[x];
    point[x]=tot;
    v[tot]=y;

}
void tarjan(int x)
{
    dfsn[x]=low[x]=++sz;
    st[++top]=x;
    ins[x]=1;
    for (int i=point[x]; i; i=Next[i])
        if (!dfsn[v[i]])
        {
            tarjan(v[i]);
            low[x]=min(low[x],low[v[i]]);
        }
        else if (ins[v[i]])  low[x]=min(low[x],dfsn[v[i]]);
    if (dfsn[x]==low[x])
    {
        ++cnt;
        int j;
        do
        {
            j=st[top--];
            belong[j]=cnt;
            size[cnt]++;
            ins[j]=0;
        }
        while (j!=x);
    }
}
void spfa(int dis[N])
{
    memset(dis,0,sizeof(dis));
    memset(can,0,sizeof(can));
    int t=belong[1];
    dis[t]=size[t];
    can[t]=1;
    queue<int> p;
    p.push(t);
    while (!p.empty())
    {
        int now=p.front();
        p.pop();
        for (int i=point[now]; i; i=Next[i])
            if (dis[v[i]]<dis[now]+size[v[i]])
            {
                dis[v[i]]=dis[now]+size[v[i]];
                if (!can[v[i]])
                {
                    can[v[i]]=1;
                    p.push(v[i]);
                }
            }
        can[now]=0;
    }
}
int main()
{

    scanf("%d%d",&n,&m);
    for (int i=1; i<=m; i++)
    {
        scanf("%d%d",&x[i],&y[i]);
        add(x[i],y[i]);
    }
    for (int i=1; i<=n; i++)
        if (!dfsn[i]) tarjan(i);

    tot=0;
    memset(point,0,sizeof(point));
    memset(Next,0,sizeof(Next));
    for (int i=1; i<=m; i++)
        if (belong[x[i]]!=belong[y[i]])   add(belong[x[i]],belong[y[i]]);
    spfa(dis);
    //cout<<endl;
    tot=0;
    memset(point,0,sizeof(point));
    memset(Next,0,sizeof(Next));
    for (int i=1; i<=m; i++)
        if (belong[x[i]]!=belong[y[i]])   add(belong[y[i]],belong[x[i]]);
    spfa(dis1);
    int ans=size[belong[1]];

    for (int i=1; i<=m; i++)
        if (belong[x[i]]!=belong[y[i]])
        {
            int t=belong[x[i]];
            int t1=belong[y[i]];
            if (dis[t1]&&dis1[t]) ans=max(ans,dis[t1]+dis1[t]-size[belong[1]]);
        }
    printf("%d
",ans);
}

C送外卖

时间限制 : - MS   空间限制 : 365536 KB 

评测说明 : 时限1000ms

问题描述

  暑期期间，何老板闲来无事，于是买了辆摩托车，签约某团外卖，跑起来送外卖的业务。
  何老板负责的区域里有n个住宅小区(编号1到n)，小区间通过m条双向道路相连，两个小区间最多只有一条道路相连，也不存在某小区自己到它自己的道路。每条道路有一定的长度。
  何老板先到1号小区的餐馆去领餐，然后去k个小区送餐(编号2,3,4,...,k+1)，最终到n号小区的加油站去给摩托车加油。要到k个小区去送餐，根据下单时间，公司规定了其中某些小区送餐的先后顺序，比如i小区的餐必须在给j小区送餐前送到。何老板希望在满足公司要求的情况下，使得行走的总路程最少，请你帮他计算一下。
  例如，下图所示，起点为1号终点为8号小区。期间要给2、3、4、5号小区送餐。公司规定，给2号小区送餐后才能给3号小区送餐，给3号小区送餐后才能给4、5号小区送餐。最短的行程方案是1—>2—>4—>3—>4—>5—>8,总路程为19。

   注意，可以先经过某些后送餐的小区而不停下来给它们送餐。假如，要送4号小区后才能给3号小区送餐，何老板可以从2号经过3号到达4号小区，中间虽然经过了3号小区，但他没有停下来，这样就不违法公司的规定了。

输入格式

第一行，3个空格间隔的整数n,m,k

   接下来m行，每行三个整数x,y,z表示小区x也小区y间有一条长度为z的道路(1<=x,y<=n   1<=z<=1000)

   接下来一行，一个整数t,表示公司有t条要求(0<=t<=k*(k-1)/2)

   接下来t行，每行两个整数x和y,表示给x小区送餐后才能给y号小区送餐
   (2<=x,y<=k+1   x!=y)

输出格式

一行，一个整数，表示所求最短总路程。

样例输入 1

8 15 4
1 2 3
1 3 4
1 4 4
1 6 2
1 7 3
2 3 6
2 4 2
2 5 2
3 4 3
3 6 3
3 8 6
4 5 2
4 8 6
5 7 4
5 8 6
3
2 3
3 4
3 5

样例输出 1

19

样例输入 2

8 7 6
1 2 10
2 3 15
3 4 1
4 5 12
5 6 13
6 7 123
7 8 10
5
7 2
2 6
6 3
3 5
5 4

样例输出 2

588

提示

对于100%的数据 2<=N<=20000, 1<=M<=200000, 0<=K<=20

最短路+状压DP
通过k+1次dijkstra预处理得到dis[i][j]为点i到点j处理出的最短路
f[j][i]表示到达i号点的最小代价，到达i号点时的访问状态为j(j为二进制的状压,记录目前已经访问过的点的集合)
f[s][p]=min{f[j][i]+dis[i][p]}
其中s=j|(1<<p-1) 且 (j&Before[p])==Before[p]
j满足Before[p]的所有前提要求
Before[p]记录到达p号点前应该具备的前提状态

#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;

#define Node pair<int, int>//<距离，编号> 
const int maxk=22;
const int INF=1000000000;
const int maxm=200005;
const int maxn=20005;

struct Edge 
{
    int End, w, Next;
    Edge(int End=0, int w=0, int Next=0):End(End),w(w),Next(Next){};//构造函数，给End,w,Next赋初值 
};

int n, m, k, All,tot;
int Last[maxn],dis[maxk][maxk],f[1048576][maxk],Before[maxk],bin[maxk],d[maxn];
bool Mark[maxn];
Edge e[maxm<<1];

int read() 
{
    int x=0, f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch == '-')f=-1;ch=getchar();};
    while (ch>='0'&&ch<='9'){ x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void add_edge(int u, int v, int w) 
{
    e[++tot].End=v, e[tot].w=w, e[tot].Next=Last[u], Last[u]=tot;
}

// 求第(1 ~ k+1)号节点到其余节点的单源最短路
void dijkstra(int x) 
{
    priority_queue<Node,vector<Node>,greater<Node> >Q;
    for(int i=1;i<=n;i++) d[i]=INF,Mark[i]=0; 
    d[x]=0;
    Q.push(make_pair(0,x));//起点进堆(距离,编号)
    while(!Q.empty()) 
    {
        int cur=Q.top().second;   Q.pop();
        if(Mark[cur])continue;else Mark[cur]=1;
        for(int i=Last[cur];i!=0;i=e[i].Next) 
        {
            if (d[cur]+e[i].w < d[e[i].End]) 
            {
                d[e[i].End]=d[cur]+e[i].w;
                Q.push(make_pair(d[e[i].End], e[i].End));
            }
        }
    }
    for(int i=1;i<=k+1;i++)dis[x][i]=d[i];
    dis[x][k+2]=d[n];  //为节约空间，dis数组大小为dis[22][22],故用k+2位置来记录x到达n的距离 
}

void dp() 
{
    int i,j,p,S;
    for(j=0;j<=All;j++)                        //枚举节点集合
        for(i=1;i<=k+1;i++)                    //枚举i号点，目前到达i号点时的状态为j 
        { 
            if(f[j][i]==-1) continue;          //不存在此状态的表示的路径则返回
            for(p=2;p<=k+1;p++)                //枚举从i出发下一个到达的点p 
            {  
                S=(j|bin[p-2]);               //将p号节点纳入路径集合
                if ((j&Before[p])==Before[p]) //判断在p节点送餐前是否已经在题目要求的所有前提节点送餐过
                    if (f[j][i]+dis[i][p]<f[S][p] || f[S][p] == -1) 
                        f[S][p]=f[j][i]+dis[i][p];// 更新最优值 
            }
        }
}

int main() 
{
    freopen("deliver.in","r",stdin);
    freopen("deliver.out","w",stdout);
    int i,j,u,v,w,t,ans=INF;
    bin[0]=1;
    for(i=1;i<22;i++) bin[i]=bin[i-1]<<1;  //bin[i]表示(i-2)号节点是否纳入路径，因为k个小区编号是2到k+1，把2当做0点处理，k+1当做k-1号点处理 
    n=read(); m=read(); k=read();          //这样全集All的值比较小，减少f[][]数组的空间 
    All=bin[k]-1;// All表示2 ~ (k+1)号节点的全集
    for(i=1;i<=m;i++) // 建图
    { 
        u=read();  v=read();  w=read();
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    for(i=1;i<=k+1;i++)dijkstra(i);// 求出1 ~ (k+1)号节点到其余节点的单源最短路
    t=read();
    for(i=1;i<=t;i++) 
    {
        u=read();   v=read();  //Before[v]记录到达v号点前应满足的集合状态 
        Before[v]+=bin[u-2];   //表示u号(用二进制的第u-2位表示)节点在v号节点前送餐
    }
    memset(f,-1,sizeof(f));
    f[0][1]=0;// 初始化,f[j][i]表示经过i集合（范围2 ~ k+1）中所有节点且当前送餐在i号节点的最短路
    dp();// 求出走完前(1 ~ k+1)号节点最终送餐在第i号节点的最短路
    ans=INF;
    for(i=1;i<=k+1;i++)
        if(f[All][i]!=-1)ans=min(ans,f[All][i]+dis[i][k+2]);// 找出走完(1 ~ k+1)号节点送餐在i到n的最短路
    printf("%d",ans);// 输出                     //dis[i][k+2]记录i到终点n的最短距离 
}