2019杭电多校第一场

1004 Vacation（HDU 6581）

链接：HDU 6581

/*****************************
杭电多校第一场 1004 Vacation

题目大意：在一个有信号灯的路口，在你的车前面有n辆车在停车等待，现在每个车给出车身长度，
最大速度，以及车头到停止线的长度，求你的车最快在多少秒之后可以通过路口 

解题思路：我们可以让每个车去跟自己的车单独比较，假设单独比较的这个车后面的所有的车都跟
其相撞，即距离变为0，那么我们遍历每个车的情况，计算出自己车追到当前车，速度变为当前车速
然后到越过停止线所需的时间，对于n个车求出的时间求max即为ans时间（追击问题） 

需要注意的是，单独考虑某一个车跟自己车时，是假设后车全部追击成功的，即车长为前缀和 ；  
******************************/
#include<bits/stdc++.h>
using namespace std;
#define ll long long

const int maxn = 100005;
int l[maxn],s[maxn],v[maxn],a[maxn];

int main()
{
	int n;
	while(cin>>n){
		double t[maxn],ans=0;
		a[0]=0;
		for(int i=0;i<=n;i++){
			scanf("%d",&l[i]);
			if(i) a[i]=a[i-1]+l[i];
		}
		for(int i=0;i<=n;i++) scanf("%d",&s[i]);
		for(int i=0;i<=n;i++) scanf("%d",&v[i]);
		for(int i=1;i<=n;i++){
			if(v[0]<=v[i]) t[i]=(s[0]*1.0)/(v[0]*1.0);
			else{
				int vv=v[0]-v[i],ss=s[0]-s[i]-a[i];
				double t0=(ss*1.0)/(vv*1.0);
				double sss=t0*v[0];
				if(s[0]<=sss) t[i]=(s[0]*1.0)/(v[0]*1.0);
				else t[i]=t0+(s[0]*1.0-sss)/(v[i]*1.0);
			}
			ans=max(ans,t[i]);
		}
		//for(int i=1;i<=n;i++) printf("%.2f\n",t[i]);
		printf("%.10f\n",ans);
	}
	return 0;
}

1005 Path（HDU 6582）最短路+最小割

链接：HDU 6582

kuangbin专题最短路有一道类似的题目HDU 3416

/**************************************************** 
杭电多校第一场 1005 Path 

题目大意：n个点，m条边，构成一个图，要求破坏最小价值使得从1到n的距离比最短
路大（有向图）； 

解题思路：将所有最短路的边添加到网络流的途中，跑一遍dinic求最小割即是ans

总结：求最短路边的时候，正着求一遍，反着求一遍，对于每一条边u,v,w，
当 dist1[u]+dist2[v]+w==dist1[n] 时，即符合最短路的边，加边即可 

********************************************************/ 
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define Pair pair<ll,ll>

const ll maxn = 10005;
const ll maxm = 20005;
const ll INF = 1e16;

ll n,m,cnt1,cnt2;
ll head1[maxn],head2[maxn],vis1[maxn],vis2[maxn],dist1[maxn],dist2[maxn],a[maxm][5];
struct node
{
    ll next,to,w;
}edge1[maxm],edge2[maxm];

void add1(ll u,ll v,ll w)
{
    edge1[cnt1].w=w;
    edge1[cnt1].to=v;
    edge1[cnt1].next=head1[u];
    head1[u]=cnt1++;
}

void add2(ll u,ll v,ll w)
{
    edge2[cnt2].w=w;
    edge2[cnt2].to=v;
    edge2[cnt2].next=head2[u];
    head2[u]=cnt2++;
}

void Dijkstra1(ll v)
{
    priority_queue<Pair,vector<Pair>,greater<Pair> >q;
    memset(vis1,0,sizeof vis1);
    for(ll i=0;i<=n;i++) dist1[i]=INF; 
    dist1[v]=0;
    q.push(Pair(0,v));
    while(!q.empty())
    {
        Pair p;
        p=q.top();
        q.pop();
        ll u=p.second;
        if(vis1[u]) continue;
        vis1[u]=true;
        for(ll i=head1[u];~i;i=edge1[i].next)
        {
            node e=edge1[i];
            if(dist1[e.to]>dist1[u]+e.w)
            {
                dist1[e.to]=dist1[u]+e.w;
                q.push(Pair(dist1[e.to],e.to));
            }
        }
    }
}

void Dijkstra2(ll v)
{
    priority_queue<Pair,vector<Pair>,greater<Pair> >q;
    memset(vis2,0,sizeof vis2);
    for(ll i=0;i<=n;i++) dist2[i]=INF;
    dist2[v]=0;
    q.push(Pair(0,v));
    while(!q.empty())
    {
        Pair p;
        p=q.top();
        q.pop();
        ll u=p.second;
        if(vis2[u]) continue;
        vis2[u]=true;
        for(ll i=head2[u];~i;i=edge2[i].next)
        {
            node e=edge2[i];
            if(dist2[e.to]>dist2[u]+e.w)
            {
                dist2[e.to]=dist2[u]+e.w;
                q.push(Pair(dist2[e.to],e.to));
            }
        }
    }
}

ll deep[maxn], dl[maxm], to[maxm], flow[maxm], fir[maxm], nxt[maxm], cnt, aim;

void add(ll u, ll v, ll w)
{
    to[cnt] = v;
    flow[cnt] = w;
    nxt[cnt] = fir[u];
    fir[u] = cnt++;
}

bool bfs(ll S, ll T)
{
    memset(deep, 0, sizeof deep);
    deep[S] = 1; dl[1] = S;
    ll head = 0, tail = 1;
    while(head != tail)
    {
        ll v = dl[++head];
        for(ll u = fir[v]; u^-1; u = nxt[u]){
            if(flow[u] && !deep[to[u]])
            {
                deep[to[u]] = deep[v]+1;
                dl[++tail] = to[u];
            }
        }
    }
    return deep[T];
}

ll dfs(ll now, ll fl)
{
    if(now == aim)return fl;
    ll f = 0;
    for(ll u = fir[now]; u^-1 && fl; u = nxt[u]){
        //fir[now] = u;
        if(flow[u] && deep[to[u]] == deep[now]+1){
            ll x = dfs(to[u], min(fl, flow[u]));
            flow[u] -= x;
            flow[u^1] += x;
            fl -= x;
            f += x;
        }
    }
    if(!f)deep[now] = -2;
    return f;
}

ll maxflow(ll S, ll T)
{
    aim = T;
    ll ans = 0;
    while(bfs(S, T))ans += dfs(S, INF);
    return ans;
}

int main()
{
	int t;
	cin>>t;
	while(t--){
		scanf("%lld%lld",&n,&m);
		memset(head1,-1,sizeof(head1));
		memset(head2,-1,sizeof(head2));
		memset(fir,-1,sizeof(fir));
		cnt1=cnt2=cnt=0;
		for(ll i=1;i<=m;i++){
			scanf("%lld%lld%lld",&a[i][0],&a[i][1],&a[i][2]);
			add1(a[i][0],a[i][1],a[i][2]);
			add2(a[i][1],a[i][0],a[i][2]);
		}
		Dijkstra1(1);
		Dijkstra2(n);
		//cout<<dist1[n]<<endl;
		for(ll i=1;i<=m;i++){
			if(dist1[a[i][0]]+dist2[a[i][1]]+a[i][2]==dist1[n]){
				add(a[i][0],a[i][1],a[i][2]);
				add(a[i][1],a[i][0],0);
			}
		}
		printf("%lld\n",maxflow(1,n));
	}
	return 0;
 }