uoj455 【UER #8】雪灾与外卖

题解：

https://blog.csdn.net/litble/article/details/88410435

https://www.mina.moe/archives/11762

以下是我瞎bb的：

如果我没看错的话，这个模拟费用流模拟的根本不是一般的最短增广路算法，模拟的是消圈算法...无语，为什么网上好像都直接当成对的了。另外，如果真的从费用流模型开始思考的话，好像会累死人而且完全没有结果；还是应该当做一个贪心来看待，费用流当做证明方法就行了

消圈算法就是先随便跑一个最大流，然后每次找出任意一个"残量网络(指只保留'原图中边和用于退流的反向边中剩余可用容量不为0的边'形成的图)中的负费用环"，增广满，直到找不到负费用环，此时就是最小费用最大流（证明咕咕咕了）

这题里面如果遇到传送点时箱子堆是空的，就直接丢进传送点堆就行（代价自然为费用-位置）；如果遇到箱子时传送点堆是空的，要假设左侧无限远处有无限个传送点（由于传送点不一定必须被匹配，但是箱子一定必须被匹配）；同样的，遇到传送点时如果进行匹配不能让答案更小，就不要匹配，直接丢进传送点堆

这题餐厅可能可以多次匹配，方法是记一个pair，第二维是剩余容量，要拆的时候拆；直接这样搞复杂度是错的，但是向餐厅堆里面插入元素的次数是可以控制的（把多次一样的插入并成插入一次一个pair），这样复杂度就对了；复杂度证明网上有

最终代码：

 1 #include<cstdio>
 2 #include<algorithm>
 3 #include<cstring>
 4 #include<vector>
 5 #include<queue>
 6 using namespace std;
 7 #define fi first
 8 #define se second
 9 #define mp make_pair
10 #define pb push_back
11 typedef long long ll;
12 typedef unsigned long long ull;
13 struct P
14 {
15     ll x,y;
16 };
17 bool operator<(const P &a,const P &b)
18 {
19     return a.x>b.x;
20 }
21 struct PP
22 {
23     int x,w,c;
24 }p[200011];
25 bool operator<(const PP &a,const PP &b)
26 {
27     return a.x<b.x;
28 }
29 int n,m;
30 ll ans;
31 priority_queue<P> q1,q2;
32 int main()
33 {
34     int i;P t;ll v,ts=0,t1,t2;
35     scanf("%d%d",&n,&m);
36     for(i=1;i<=n;++i)
37     {
38         scanf("%d",&p[i].x);
39         p[i].c=-1;
40     }
41     for(i=1;i<=m;++i)
42     {
43         scanf("%d%d%d",&p[i+n].x,&p[i+n].w,&p[i+n].c);
44         ts+=p[i+n].c;
45     }
46     if(n>ts)    {puts("-1");return 0;}
47     sort(p+1,p+n+m+1);
48     for(i=1;i<=n+m;++i)
49     {
50         if(p[i].c==-1)
51         {
52             if(q2.empty())    v=1e11;
53             else
54             {
55                 t=q2.top();q2.pop();
56                 v=t.x;
57                 if(t.y!=1)    q2.push((P){t.x,t.y-1});
58             }
59             ans+=p[i].x+v;
60             q1.push((P){-2*p[i].x-v,1});
61         }
62         else
63         {
64             t1=0;
65             while(p[i].c && !q1.empty())
66             {
67                 t=q1.top();v=t.x;
68                 if(p[i].x+p[i].w+v>=0)    break;
69                 q1.pop();
70                 t2=min(ll(p[i].c),t.y);
71                 t.y-=t2;p[i].c-=t2;
72                 ans+=t2*(p[i].x+p[i].w+v);
73                 t1+=t2;
74                 q2.push((P){-2*p[i].x-v,t2});
75                 if(t.y)    q1.push(t);
76             }
77             if(t1)    q1.push((P){-p[i].x-p[i].w,t1});
78             if(p[i].c)    q2.push((P){p[i].w-p[i].x,p[i].c});
79         }
80     }
81     printf("%lld\n",ans);
82     return 0;
83 }

View Code

暴力（最暴力的费用流，$O(n^2)$条边）：

  1 #include<cstdio>
  2 #include<algorithm>
  3 #include<cstring>
  4 #include<vector>
  5 #include<queue>
  6 #include<ext/pb_ds/assoc_container.hpp>
  7 #include<ext/pb_ds/priority_queue.hpp>
  8 using namespace std;
  9 #define fi first
 10 #define se second
 11 #define pb push_back
 12 typedef long long ll;
 13 typedef unsigned long long ull;
 14 struct pli
 15 {
 16     ll fi;int se;
 17 };
 18 bool operator>(const pli &a,const pli &b)
 19 {
 20     return a.fi>b.fi || (a.fi==b.fi && a.se>b.se);
 21 }
 22 const ll inf=0x3f3f3f3f3f3f3f3f;
 23 namespace F
 24 {
 25 
 26 struct E
 27 {
 28     int to,nxt,from;
 29     ll d,cap,flow;
 30 }e[1010000];
 31 int f1[5010],ne=1;
 32 int S,T,n;
 33 bool inq[5010],*vis=inq;
 34 ll d[5010];
 35 ll h[5010];
 36 ll flow,cost;
 37 typedef __gnu_pbds::priority_queue<pli,greater<pli> > pq;
 38 pq::point_iterator it[5010];
 39 //const int INF=0x3f3f3f3f;
 40 bool spfa()
 41 {
 42     int u,k,k1;
 43     memset(d,0x3f,sizeof(d[0])*(n+1));
 44     memset(inq,0,sizeof(inq[0])*(n+1));
 45     queue<int> q;
 46     q.push(T);d[T]=0;inq[T]=1;
 47     while(!q.empty())
 48     {
 49         u=q.front();q.pop();
 50         inq[u]=0;
 51         for(k1=f1[u];k1;k1=e[k1].nxt)
 52         {
 53             k=k1^1;
 54             if(e[k].cap>e[k].flow&&d[u]+e[k].d<d[e[k].from])
 55             {
 56                 d[e[k].from]=d[u]+e[k].d;
 57                 if(!inq[e[k].from])
 58                 {
 59                     inq[e[k].from]=1;
 60                     q.push(e[k].from);
 61                 }
 62             }
 63         }
 64     }
 65     return d[S]!=inf;
 66 }
 67 bool dij()
 68 {
 69     int i,u,k,k1;pli t;
 70     memset(d,0x3f,sizeof(d[0])*(n+1));
 71     memset(vis,0,sizeof(vis[0])*(n+1));
 72     pq q;
 73     for(i=1;i<=n;i++)    it[i]=q.end();
 74     it[T]=q.push((pli){0,T});d[T]=0;
 75     while(!q.empty())
 76     {
 77         t=q.top();q.pop();
 78         u=t.se;
 79         if(vis[u])    continue;
 80         vis[u]=1;
 81         for(k1=f1[u];k1;k1=e[k1].nxt)
 82         {
 83             k=k1^1;
 84             if(e[k].cap>e[k].flow&&d[u]+e[k].d+h[u]-h[e[k].from]<d[e[k].from])
 85             {
 86                 d[e[k].from]=d[u]+e[k].d+h[u]-h[e[k].from];
 87                 if(it[e[k].from]!=q.end())    q.modify(it[e[k].from],(pli){d[e[k].from],e[k].from});
 88                 else    it[e[k].from]=q.push((pli){d[e[k].from],e[k].from});
 89             }
 90         }
 91     }
 92     return d[S]!=inf;
 93 }
 94 void update()
 95 {
 96     for(int i=1;i<=n;i++)    h[i]+=d[i];
 97 }
 98 ll dfs(int u,ll x)
 99 {
100     if(u==T||x==0)    return x;
101     ll flow=0,f;
102     vis[u]=1;
103     for(int k=f1[u];k;k=e[k].nxt)
104         if(!vis[e[k].to]&&e[k].cap>e[k].flow&&h[e[k].to]==h[u]-e[k].d)
105         {
106             f=dfs(e[k].to,min(x-flow,e[k].cap-e[k].flow));
107             e[k].flow+=f;e[k^1].flow-=f;flow+=f;
108             if(flow==x)    return flow;
109         }
110     return flow;
111 }
112 void augment()
113 {
114     ll f;
115     while(1)
116     {
117         memset(vis,0,sizeof(vis[0])*(n+1));
118         f=dfs(S,inf);
119         if(!f)    break;
120         flow+=f;cost+=f*h[S];
121     }
122 }
123 void solve()
124 {
125     flow=cost=0;
126     memset(h,0,sizeof(h[0])*(n+1));
127     if(!spfa())    return;
128     do
129     {
130         update();
131         augment();
132     }while(dij());
133 }
134 void me(int a,int b,ll c,ll d)
135 {
136     e[++ne].to=b;e[ne].nxt=f1[a];f1[a]=ne;e[ne].from=a;
137     e[ne].cap=c;e[ne].d=d;
138     e[++ne].to=a;e[ne].nxt=f1[b];f1[b]=ne;e[ne].from=b;
139     e[ne].cap=0;e[ne].d=-d;
140 }
141 
142 }
143 
144 ll abs1(ll a){return a>=0?a:-a;}
145 int n,m;
146 int x[100011],y[100011],w[100011],c[100011];
147 int main()
148 {
149     int i,j;ll ts=0;
150     scanf("%d%d",&n,&m);
151     for(i=1;i<=n;++i)
152         scanf("%d",x+i);
153     for(i=1;i<=m;++i)
154     {
155         scanf("%d%d%d",y+i,w+i,c+i);
156         ts+=c[i];
157     }
158     if(n>ts)    {puts("-1");return 0;}
159     F::S=n+m+1;F::T=n+m+2;F::n=n+m+2;
160     for(i=1;i<=n;++i)
161         F::me(F::S,i,1,0);
162     for(i=1;i<=n;++i)
163         for(j=1;j<=m;++j)
164             F::me(i,j+n,inf,abs1(x[i]-y[j]));
165     for(i=1;i<=m;++i)
166         F::me(i+n,F::T,c[i],w[i]);
167     F::solve();
168     printf("%lld\n",F::cost);
169     return 0;
170 }

View Code

暴力（优化到O(n)条边）：

  1 %:pragma GCC optimize("Ofast")
  2 #include<cstdio>
  3 #include<algorithm>
  4 #include<cstring>
  5 #include<vector>
  6 #include<queue>
  7 #include<ext/pb_ds/assoc_container.hpp>
  8 #include<ext/pb_ds/priority_queue.hpp>
  9 using namespace std;
 10 #define fi first
 11 #define se second
 12 #define pb push_back
 13 typedef long long ll;
 14 typedef unsigned long long ull;
 15 struct pli
 16 {
 17     ll fi;int se;
 18 };
 19 bool operator>(const pli &a,const pli &b)
 20 {
 21     return a.fi>b.fi || (a.fi==b.fi && a.se>b.se);
 22 }
 23 const ll inf=0x3f3f3f3f3f3f3f3f;
 24 namespace F
 25 {
 26 
 27 struct E
 28 {
 29     int to,nxt,from;
 30     ll d,cap,flow;
 31 }e[2010001];
 32 int f1[400011],ne=1;
 33 int S,T,n;
 34 bool inq[400011],*vis=inq;
 35 ll d[400011];
 36 ll h[400011];
 37 ll flow,cost;
 38 typedef __gnu_pbds::priority_queue<pli,greater<pli> > pq;
 39 pq::point_iterator it[400011];
 40 //const int INF=0x3f3f3f3f;
 41 bool spfa()
 42 {
 43     int u,k,k1;
 44     memset(d,0x3f,sizeof(d[0])*(n+1));
 45     memset(inq,0,sizeof(inq[0])*(n+1));
 46     queue<int> q;
 47     q.push(T);d[T]=0;inq[T]=1;
 48     while(!q.empty())
 49     {
 50         u=q.front();q.pop();
 51         inq[u]=0;
 52         for(k1=f1[u];k1;k1=e[k1].nxt)
 53         {
 54             k=k1^1;
 55             if(e[k].cap>e[k].flow&&d[u]+e[k].d<d[e[k].from])
 56             {
 57                 d[e[k].from]=d[u]+e[k].d;
 58                 if(!inq[e[k].from])
 59                 {
 60                     inq[e[k].from]=1;
 61                     q.push(e[k].from);
 62                 }
 63             }
 64         }
 65     }
 66     return d[S]!=inf;
 67 }
 68 bool dij()
 69 {
 70     int i,u,k,k1;pli t;
 71     memset(d,0x3f,sizeof(d[0])*(n+1));
 72     memset(vis,0,sizeof(vis[0])*(n+1));
 73     pq q;
 74     for(i=1;i<=n;i++)    it[i]=q.end();
 75     it[T]=q.push((pli){0,T});d[T]=0;
 76     while(!q.empty())
 77     {
 78         t=q.top();q.pop();
 79         u=t.se;
 80         if(vis[u])    continue;
 81         vis[u]=1;
 82         for(k1=f1[u];k1;k1=e[k1].nxt)
 83         {
 84             k=k1^1;
 85             if(e[k].cap>e[k].flow&&d[u]+e[k].d+h[u]-h[e[k].from]<d[e[k].from])
 86             {
 87                 d[e[k].from]=d[u]+e[k].d+h[u]-h[e[k].from];
 88                 if(it[e[k].from]!=q.end())    q.modify(it[e[k].from],(pli){d[e[k].from],e[k].from});
 89                 else    it[e[k].from]=q.push((pli){d[e[k].from],e[k].from});
 90             }
 91         }
 92     }
 93     return d[S]!=inf;
 94 }
 95 void update()
 96 {
 97     for(int i=1;i<=n;i++)    h[i]+=d[i];
 98 }
 99 ll dfs(int u,ll x)
100 {
101     if(u==T||x==0)    return x;
102     ll flow=0,f;
103     vis[u]=1;
104     for(int k=f1[u];k;k=e[k].nxt)
105         if(!vis[e[k].to]&&e[k].cap>e[k].flow&&h[e[k].to]==h[u]-e[k].d)
106         {
107             f=dfs(e[k].to,min(x-flow,e[k].cap-e[k].flow));
108             e[k].flow+=f;e[k^1].flow-=f;flow+=f;
109             if(flow==x)    return flow;
110         }
111     return flow;
112 }
113 void augment()
114 {
115     ll f;
116     while(1)
117     {
118         memset(vis,0,sizeof(vis[0])*(n+1));
119         f=dfs(S,inf);
120         if(!f)    break;
121         flow+=f;cost+=f*h[S];
122     }
123 }
124 void solve()
125 {
126     flow=cost=0;
127     memset(h,0,sizeof(h[0])*(n+1));
128     if(!spfa())    return;
129     do
130     {
131         update();
132         augment();
133     }while(dij());
134 }
135 void me(int a,int b,ll c,ll d)
136 {
137     e[++ne].to=b;e[ne].nxt=f1[a];f1[a]=ne;e[ne].from=a;
138     e[ne].cap=c;e[ne].d=d;
139     e[++ne].to=a;e[ne].nxt=f1[b];f1[b]=ne;e[ne].from=b;
140     e[ne].cap=0;e[ne].d=-d;
141     //printf("1t%d %d %lld %lld\n",a,b,c,d);
142 }
143 
144 }
145 
146 ll abs1(ll a){return a>=0?a:-a;}
147 int n,m;
148 int x[100011],y[100011],w[100011],c[100011];
149 int main()
150 {
151     int i,j;ll ts=0;
152     scanf("%d%d",&n,&m);
153     for(i=1;i<=n;++i)
154         scanf("%d",x+i);
155     for(i=1;i<=m;++i)
156     {
157         scanf("%d%d%d",y+i,w+i,c+i);
158         ts+=c[i];
159     }
160     if(n>ts)    {puts("-1");return 0;}
161     F::S=n+3*m+1;F::T=n+3*m+2;F::n=n+3*m+2;
162     for(i=1;i<m;++i)
163         F::me(i,i+1,inf,y[i+1]-y[i]);
164     for(i=m;i>1;--i)
165         F::me(i+m,i-1+m,inf,y[i]-y[i-1]);
166     for(i=1;i<=m;++i)
167     {
168         F::me(i,i+2*m,inf,0);
169         F::me(i+m,i+2*m,inf,0);
170         F::me(i+2*m,F::T,c[i],w[i]);
171     }
172     for(i=1,j=1;i<=n;++i)
173     {
174         while(j<=m && y[j]<x[i])    ++j;
175         if(j!=1)    F::me(i+3*m,j-1+m,1,x[i]-y[j-1]);
176         if(j!=m+1)    F::me(i+3*m,j,1,y[j]-x[i]);
177         F::me(F::S,i+3*m,1,0);
178     }
179     F::solve();
180     printf("%lld\n",F::cost);
181     return 0;
182 }

View Code

数据生成器

 1 #include<cstdio>
 2 #include<algorithm>
 3 #include<cstring>
 4 #include<vector>
 5 #include<chrono>
 6 using namespace std;
 7 #define fi first
 8 #define se second
 9 #define mp make_pair
10 #define pb push_back
11 typedef long long ll;
12 typedef unsigned long long ull;
13 ull splitmix64(ull x) {
14     x += 0x9e3779b97f4a7c15;
15     x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
16     x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
17     return x ^ (x >> 31);
18 }
19 ull rd()
20 {
21     static ull x=splitmix64(chrono::steady_clock::now().time_since_epoch().count());
22     return splitmix64(x=x*6364136223846793005ull+1442695040888963407ull);
23 }
24 ll randint(ll l,ll r)
25 {
26     return rd()%(r-l+1)+l;
27 }
28 int n=randint(2,5),m=randint(2,5);
29 struct P
30 {
31     int y,w,c;
32 }t2[100011];
33 bool operator<(const P &a,const P &b)
34 {
35     return a.y<b.y;
36 }
37 int t1[100011];
38 int main()
39 {
40     int i;
41     for(i=1;i<=n;++i)
42         t1[i]=randint(0,1e9);
43     for(i=1;i<=m;++i)
44         t2[i].y=randint(0,1e9),t2[i].w=randint(0,1e9),t2[i].c=randint(0,1e9);
45     sort(t1+1,t1+n+1);
46     sort(t2+1,t2+m+1);
47     printf("%d %d\n",n,m);
48     for(i=1;i<=n;++i)
49         printf("%d ",t1[i]);
50     puts("");
51     for(i=1;i<=m;++i)
52         printf("%d %d %d\n",t2[i].y,t2[i].w,t2[i].c);
53     return 0;
54 }

View Code

对拍脚本

#!/bin/bash
set -v on
while [ 1 = 1 ]
do
    ./1_2.out >t1.txt
    echo "running 1"
    ./1.out <t1.txt >t2.txt
    echo "running 2"
    ./1_1.out <t1.txt >t3.txt
    diff -w t2.txt t3.txt
    if [ $? != 0 ]
        then    read -n 1
    fi
    cat t2.txt
done

View Code

优化暴力和最终代码拍了一下，应该是没问题了

一堆草稿...

令 𝑣𝑖为某种方式得到一个洞的权值，𝑤𝑖为某种方式得到一只兔子的权值，𝑥𝑖为兔子的坐标，𝑦𝑖为洞的坐标，𝑠𝑖为一个洞的附加权值。
一只兔子b如果选择洞a，总权值的增加量即为$w_a-y_a+x_b$。之后一个好洞c替换这个坏洞时，总权值又会增加$-(w_a-y_a)+y_c-2x_b$，对于好洞c来说，它找到了一只兔子，并且产生了$-(w_a-y_a)+y_c-2x_b$的贡献，因此我们可以新增加一只权值为$-(w_a-y_a)-x_b$的兔子。
一个洞 𝑏如果找到了兔子 𝑎，总权值的增加量 𝑤𝑎+𝑦𝑏+𝑠𝑏。之后一个兔子 𝑐抢走了这个洞时，总权值又会增加 𝑥𝑐−𝑤𝑎−2𝑦𝑏，对于 𝑐来说，它找到了一个洞，而 𝑎也不会因此无家可归，因为当我们处理 𝑎的时候，我们肯定为它分配了在它前面的洞，后来 𝑏找到了 𝑎，现在 𝑏把 𝑎赶走了，𝑎显然可以回去找之前分配给它的洞，赶走里面住的兔子，以此类推。这样，一切又回到了 𝑏没有发现 𝑎时的模样，因此，对于 𝑐来说，我们可以新增一个权值为 −𝑤𝑎−2𝑦𝑏的洞。
一个洞 𝑏如果找到了兔子 𝑎，总权值增加量 𝑤𝑎+𝑦𝑏+𝑠𝑏。之后一个新的洞 𝑐替代了 𝑏，总权值又会增加 𝑦𝑐+𝑠𝑐−𝑦𝑏−𝑠𝑏，对于 𝑐来说，它找到了一个权值为 −𝑦𝑏−𝑠𝑏的兔子，因此我们新增一个这样的兔子。

令$x_i$为兔子的坐标，$y_i$为洞的坐标，$s_i$为一个洞的附加权值。
一只兔子b如果选择洞a，总权值的增加量即为$s_a-y_a+x_b$。之后一个好洞c替换这个坏洞a时，总权值又会增加$-(s_a-y_a+x_b)+y_c+s_c-x_b=-s_a+y_a+y_c+s_c-2x_b$，对于好洞c来说，它找到了一只兔子，并且产生了$-s_a+y_a+y_c+s_c-2x_b$的贡献，因此我们可以新增加一只权值为$(-s_a+y_a+y_c+s_c-2x_b)-($的兔子。
一个洞 𝑏如果找到了兔子 𝑎，总权值的增加量 𝑤𝑎+𝑦𝑏+𝑠𝑏。之后一个兔子 𝑐抢走了这个洞时，总权值又会增加 𝑥𝑐−𝑤𝑎−2𝑦𝑏，对于 𝑐来说，它找到了一个洞，而 𝑎也不会因此无家可归，因为当我们处理 𝑎的时候，我们肯定为它分配了在它前面的洞，后来 𝑏找到了 𝑎，现在 𝑏把 𝑎赶走了，𝑎显然可以回去找之前分配给它的洞，赶走里面住的兔子，以此类推。这样，一切又回到了 𝑏没有发现 𝑎时的模样，因此，对于 𝑐来说，我们可以新增一个权值为 −𝑤𝑎−2𝑦𝑏的洞。
一个洞 𝑏如果找到了兔子 𝑎，总权值增加量 𝑤𝑎+𝑦𝑏+𝑠𝑏。之后一个新的洞 𝑐替代了 𝑏，总权值又会增加 𝑦𝑐+𝑠𝑐−𝑦𝑏−𝑠𝑏，对于 𝑐来说，它找到了一个权值为 −𝑦𝑏−𝑠𝑏的兔子，因此我们新增一个这样的兔子。

将兔子和洞从左到右排序，依次考虑。
匹配有两种：兔子与其之前的洞匹配(a类)，洞与其之前的兔子匹配(b类)。
具体来说：
加入一个兔子，先与已经被考虑过的洞中剩余未被匹配的洞中最靠后的匹配（如果没有，就假设左侧无限远处有无限个的洞），可能要与之前的某个兔子交换洞。
遇到一个洞，可能会将之前某只兔子改为与其匹配。

设兔子的坐标为$x_i$，洞的坐标为$y_i$，洞的附加权值为$s_i$。
维护一个堆q1，存放"已经被考虑过的洞中剩余未被匹配的洞"的信息。
维护一个堆q2，存放"可能会在加入新洞的时候改变匹配的兔子"的信息。
一个兔子b选择洞a，总权值增加$s_a-y_a+x_b$。之后一个好洞c替换a时，总权值增加$-(s_a-y_a+x_b)+(y_c+s_c-x_b)=y_c+s_c-s_a+y_a-2x_b$。因此q2中放入一个$-s_a+y_a-2x_b$

我完全没看出来以下算法跟费用流有什么关系，也没看出来为什么是对的...
一个简化版的问题：如果每个洞容量都为1?
将兔子和洞从左到右排序，依次考虑。
匹配有两种：兔子与其之前的洞匹配(a类)，洞与其之前的兔子匹配(b类)。
几种情况：
(废弃,可以发现无论如何都不可能更优)1.a类兔子A与之前的洞B匹配，可能洞会被A之后的兔子C抢走(指A与C交换它们所在的洞)("抢"前后都是a类)
1.a类兔子A与之前的洞B匹配，可能兔子会被A之后的洞C抢走,B就返回未被匹配时的状态("抢"前后由a类变成b类)
2.b类兔子A与之后的洞B匹配，可能洞会被B之后的兔子抢走，同时A回到前一次分配给它的洞(可能还会"递归"地将一些其他兔子赶回它们前一次所在的洞)("抢"前后由b类变成a类)
3.每遇到一个洞，都优先从
具体来说：
设兔子i的坐标为$x_i$，洞i的坐标为$y_i$，洞i的附加权值为$s_i$。
维护两个堆q1,q2，分别存放之前未使用的兔子/洞的"权值"。（刚插入堆的洞i的权值为$s_i-y_i$，兔子i的权值为$$）
遇到一个兔子b，先在q2中取出一个权值最小的洞(权值为a)，与之匹配，产生贡献为$x_b+a$。如果有一个兔子d，原来匹配的洞权值是c(c,d间的匹配是a类)，那么可能要改为d匹配洞a，b匹配洞c。可以发现修改前后贡献不变（都为$x_b+a+x_d+c$），因此在q2中放入一个权值为$$

问题：
数轴上有一些兔子和洞。一个兔子必须进一个洞，一个洞可以进一定容量的兔子(每个洞容量可能不同)。兔子可以向两边走，洞每进一个兔子需要一定额外费用(每个洞可能不同)，最小化兔子行走的距离及选择的洞的额外费用之和。
我完全没看出来以下算法跟费用流有什么关系，也没看出来为什么是对的...
#猜了一下，大概是这样的意思：由于这个可以表示为费用流模型，且最大流是已知的（就是兔子数），如果任意得到一个方案，只需要不断做能使费用和变小的调整操作，最终一定能得到一种最优方案（这个结论真的对吗，我不会证）?
一个简化版的问题：如果每个洞容量都为1?
将兔子和洞从左到右排序，依次考虑。
设兔子i的坐标为$x_i$，洞i的坐标为$y_i$，洞i的附加权值为$s_i$。
维护两个堆q1,q2，分别存放之前未使用的兔子/洞的代价。（代价是人为定义的，新插入堆的洞i的权值为$s_i-y_i$，兔子i的权值为$$）
#匹配有两种：兔子与其之前的洞匹配(a类)，洞与其之前的兔子匹配(b类)。
遇到一个兔子A，先把它与q2中代价最小(设代价为v)的洞匹配（如果没有了就假设左侧无限远处有无限个洞，这是由于所有兔子都必须匹配）。产生贡献$x_A+v$
可能有之后的兔子抢夺这个洞，。
可能有之后的洞(设为C)抢夺这个兔子，抢夺之后贡献变为$y_C-x_A+s_C$，增加了$y_C+s_C-2x_A-v$，因此向q1中放入一个权值为$-2x_A-v$的兔子来模拟撤销
遇到一个洞B，先把它与q1中代价最小(设代价为v)的兔子里匹配（如果没有了就直接放入q2，后面都不管）。
可能有之后的兔子抢夺这个洞，那么

下面有隐藏的备份...(尝试修过一些锅，不过可能越修越锅了也说不定?)

https://blog.csdn.net/litble/article/details/88410435

基础模型

你在玩一款益智推箱子游戏。

数轴上有n个箱子和m个传送点，第i个箱子在$x_i$，第i个传送点在$y_i$。当箱子放在传送点上时可以传送走，每个传送点可以最多送走一个箱子，传送走所有箱子视为通关。

你可以做的唯一操作是将一个箱子向左推一个单位，耗费代价1，过程中允许有多个箱子在同一位置或者箱子在传送点位置但没被送走，问你通关的最小代价。

只要从左到右依次考虑每个物件（传送点或箱子），然后将箱子送入最右边还未被使用的传送点即可，用一个栈就能完成。

变形1.激活传送点

你在开始推箱子前，需要选择若干个传送点激活，只有激活了的传送点才能使用，激活第i个传送点的代价是$w_i$。箱子只能往左推，推一个单位花费1的代价。

不一定要传送走所有箱子，最大化代价。

依然从左往右考虑每个物件。

若物件是一个箱子a，推入传送点b产生代价是$x_a−y_b+w_b$，所以要取$−y_b+w_b$最大的传送点，用堆维护传送点即可。若$x_a−y_b+w_b$一定小于0，则不使用该箱子。

但是这只是个只顾眼前利益的贪心而已，可能最优的解是a之后的一个箱子c和传送点b匹配，a不匹配呢？如果要更改b匹配的箱子的话，应该要在答案里减去箱子a造成的贡献，即相当于添加一个价值为$−x_a$的箱子。

取消a与b的匹配，改为c与b的匹配，这很像一个费用流的退流操作（事实上后面的模型会更像，因为这个还只是退流一次，没有什么c抢走b，a就去匹配它本来匹配过的d，然后现在匹配d的节点又去……这种），实际上模拟费用流的本质就是用其他东西来模拟退流。

bzoj4977 跳伞求生

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 #define RI register int
 4 int read() {
 5     int q=0;char ch=' ';
 6     while(ch<'0'||ch>'9') ch=getchar();
 7     while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
 8     return q;
 9 }
10 typedef long long LL;
11 int n,m;LL ans;
12 struct node{int x,c;}d[200005];
13 bool cmp(node A,node B) {return A.x==B.x?A.c==-1:A.x<B.x;}
14 priority_queue<int> q;
15 
16 int main()
17 {
18     n=read(),m=read();
19     for(RI i=1;i<=n;++i) d[i].x=read(),d[i].c=-1;
20     for(RI i=1;i<=m;++i) d[n+i].x=read(),d[n+i].c=read();
21     sort(d+1,d+1+n+m,cmp);
22     for(RI i=1;i<=n+m;++i) {
23         if(d[i].c==-1) {
24             if(q.empty()||q.top()+d[i].x<=0) continue;
25             ans+=q.top()+d[i].x,q.pop(),q.push(-d[i].x);
26         }
27         else q.push(d[i].c-d[i].x);
28     }
29     printf("%lld\n",ans);
30     return 0;
31 }

View Code

变形2.必须传送掉

在任何一种条件组合的基础上，箱子必须被传送掉，最小化代价。

那么先让每个箱子都与一个激活代价为INF的传送点匹配，这个匹配是不可退流的。

变形3.左右都可走

箱子必须匹配一个传送点，传送点最多匹配一个箱子，传送点有激活代价，箱子可以向左推也可以向右推。

同样从左往右考虑每个物件。

若是一个箱子a，在传送点堆中找一个代价最小的传送点b，假设代价为$v_b$，那么现在产生的贡献是$x_a+v_b$。

考虑后续有一个箱子要抢夺传送点b，理论上应该加一个代价为$−x_a$的传送点，不过因为箱子都必须匹配，所以完成a与b的匹配时其实是除去了一个INF的a本来和代价INF的虚拟传送点匹配的代价，所以应该加的是代价为$INF−x_a$的传送点，也就不用加这个传送点了。

考虑后续有一个传送点要抢夺箱子a，除去贡献，添加一个价值为$-v_b-2x_a$的箱子。

若是一个传送点a，在箱子堆中找一个代价最小的箱子b，设代价为$v_b$，那么现在产生的贡献是$y_a+w_a+v_b$。

考虑后续有一个箱子要抢夺传送点a，添加一个代价为$−v_b−2y_a$的传送点。

考虑后续有一个传送点要抢夺箱子b，添加一个代价为$-y_a-w_a$的箱子。

变形4.分身

在任意条件组合基础上，添加“传送点最多可以激活$c_i$次，每次激活代价为$w_i$”或“第i个位置叠着$d_i$个箱子”这两个条件，$c_i$和$d_i$都较大（$10^9$级别）

在堆里直接放一个pair，记录一下这种箱子或传送点有多少个即可。什么？你说合并的时候产生的新箱子和新传送点数目可能会很多？呃，这个是可以证明不会产生太多的，好像是用什么匹配不会交叉证，但我不会，嘤嘤嘤。

接下来可以做一道题了，UOJ#455 雪灾与外卖

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 #define RI register int
 4 int read() {
 5     int q=0;char ch=' ';
 6     while(ch<'0'||ch>'9') ch=getchar();
 7     while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
 8     return q;
 9 }
10 typedef long long LL;
11 typedef pair<LL,LL> PR;
12 const LL inf=1e15;
13 const int N=100005;
14 int n,m;LL ans,sumc;
15 struct node{LL x,w,c;}t[N<<1];
16 bool cmp(node A,node B) {return A.x<B.x;}
17 priority_queue<PR,vector<PR>,greater<PR> > q1,q2;
18 
19 void work() {
20     q1.push((PR){inf,n});
21     for(RI i=1;i<=n+m;++i) {
22         if(t[i].w==-1) {
23             PR kl=q1.top();LL kv=kl.first;q1.pop();
24             ans+=kv+t[i].x,--kl.second;
25             if(kl.second) q1.push(kl);
26             q2.push((PR){-kv-2*t[i].x,1});
27         }
28         else {
29             LL num=t[i].c,sumsum=0;
30             while(num&&(!q2.empty())) {
31                 PR kl=q2.top();LL kv=kl.first;
32                 if(kv+t[i].w+t[i].x>=0) break;
33                 q2.pop();LL sum=min(kl.second,num);
34                 ans+=(kv+t[i].w+t[i].x)*sum,kl.second-=sum,num-=sum;
35                 if(kl.second) q2.push(kl);
36                 sumsum+=sum,q1.push((PR){-kv-2*t[i].x,sum});
37             }
38             if(sumsum) q2.push((PR){-t[i].x-t[i].w,sumsum});
39             if(num) q1.push((PR){t[i].w-t[i].x,num});
40         }
41     }
42 }
43 int main()
44 {
45     n=read(),m=read();
46     for(RI i=1;i<=n;++i) t[i].x=read(),t[i].w=-1,t[i].c=0;
47     for(RI i=1;i<=m;++i)
48         t[i+n].x=read(),t[i+n].w=read(),t[i+n].c=read(),sumc+=t[i+n].c;
49     if(sumc<(LL)n) {puts("-1");return 0;}
50     sort(t+1,t+1+n+m,cmp),work();
51     printf("%lld\n",ans);
52     return 0;
53 }

View Code

变形5.分身必须匹配一个

若分身必须匹配一个，拆成两种，一种有一个，匹配后产生额外价值−INF（求最小价值），一种有$c_i−1$个，匹配后产生额外价值0。

变形6.上树

上树愉快！使用可并堆，自底向上合并，每一次合并将来自不同子树的箱子和传送点配一配。

复杂度还是不会证QAQ。

loj#6405 征服世界

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 #define RI register int
 4 int read() {
 5     int q=0;char ch=' ';
 6     while(ch<'0'||ch>'9') ch=getchar();
 7     while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
 8     return q;
 9 }
10 typedef long long LL;
11 typedef pair<LL,int> PR;
12 const int N=250005;
13 const LL inf=1e12;
14 int n,tot,SZ;LL ans;
15 int h[N],ne[N<<1],to[N<<1],X[N],Y[N],rtX[N],rtY[N];LL dis[N],w[N<<1];
16 struct node{int ls,rs,d;PR v;}tr[N*30];
17 //申请超大结构体要花很多时间，建议拆成单个数组。
18 
19 int merge(int a,int b) {
20     if(!a||!b) return a|b;
21     if(tr[a].v>tr[b].v) swap(a,b);
22     tr[a].rs=merge(tr[a].rs,b);
23     if(tr[tr[a].rs].d>tr[tr[a].ls].d) swap(tr[a].ls,tr[a].rs);
24     tr[a].d=tr[tr[a].rs].d+1;return a;
25 }
26 int newnode(LL val,int sum)
27     {++SZ,tr[SZ].v=(PR){val,sum},tr[SZ].d=1;return SZ;}
28 
29 void add(int x,int y,LL z) {to[++tot]=y,ne[tot]=h[x],h[x]=tot,w[tot]=z;}
30 void mer(int x,int y,LL d) {
31     while(rtX[x]&&rtY[y]) {
32         LL v1=tr[rtX[x]].v.first,v2=tr[rtY[y]].v.first;
33         if(v1+v2-2*d>=0) break;
34         int sum=min(tr[rtX[x]].v.second,tr[rtY[y]].v.second);
35         ans+=(v1+v2-2*d)*sum;
36         tr[rtX[x]].v.second-=sum,tr[rtY[y]].v.second-=sum;
37         if(!tr[rtX[x]].v.second) rtX[x]=merge(tr[rtX[x]].ls,tr[rtX[x]].rs);
38         if(!tr[rtY[y]].v.second) rtY[y]=merge(tr[rtY[y]].ls,tr[rtY[y]].rs);
39         rtX[x]=merge(rtX[x],newnode(-v2+2*d,sum));
40         rtY[y]=merge(rtY[y],newnode(-v1+2*d,sum));
41     }
42 }
43 void dfs(int x,int las) {
44     if(X[x]) rtX[x]=newnode(dis[x],X[x]);
45     if(Y[x]) rtY[x]=newnode(dis[x]-inf,Y[x]),ans+=1LL*Y[x]*inf;
46     for(RI i=h[x];i;i=ne[i]) {
47         int y=to[i];if(y==las) continue;
48         dis[y]=dis[x]+w[i],dfs(y,x);
49         mer(x,y,dis[x]),mer(y,x,dis[x]);
50         rtX[x]=merge(rtX[x],rtX[y]),rtY[x]=merge(rtY[x],rtY[y]);
51     }
52 }
53 int main()
54 {
55     int x,y,z;
56     n=read();
57     for(RI i=1;i<n;++i)
58         x=read(),y=read(),z=read(),add(x,y,z),add(y,x,z);
59     for(RI i=1;i<=n;++i) {
60         X[i]=read(),Y[i]=read();
61         int kl=min(X[i],Y[i]);
62         X[i]-=kl,Y[i]-=kl;
63     }
64     dfs(1,0);
65     printf("%lld\n",ans);
66     return 0;
67 }

View Code

下面有隐藏的备份...

模拟费用流

简介

费用流是解决一些最优化问题的常用算法。可以认为，费用流问题是线性规划问题的一个子集，而模拟费用流又是费用流问题的一个子集。模拟费用流方法的适用范围没有它的两个超集广，但是效率却远远高于这两种普适方法。

模拟费用流方法是指利用除费用流以外的手段解决一些费用流问题。一般来说，一个问题如果使用模拟费用流算法来解决，你在整个代码中不会见到任何一个与费用流有关的片段。可以说，这个方法非常的抽象。

在将问题抽象为线性规划模型后，我们可以无脑单纯形、内点法，也可以尝试用网络和流量描述这个问题，就可以使用费用流算法。如果这个问题还可以进一步转化为类似 “带权匹配” 这样的问题，就可以考虑模拟费用流了。

在模拟费用流问题的分析上，我个人常用的方法分为以下几种：

观察 Dp 方程
观察流量网络
Dp 方程的二维直观表示
括号序列与折线法
单调性和凹凸性分析
匹配

一般来说，这些方法结合分析可以让问题变得简单。在解决问题的过程中，每一个步骤都有着一个更合适的分析方法，而分析出了一些结论或者性质后，不同的方法之间又能产生很多优美的等价关系。这种分析的过程也可以给解决其它问题带来灵感。

模型 1

一个兔子必须进一个洞，一个洞最多进一个兔子。兔子只能往左走。最小化兔子行走的距离之和。

这个问题可以结合括号序列分析。将所有兔子，以及最终有兔子进去的洞拿出来，不难发现，对于这些元素的任何一个前缀，兔子总不会比洞多。因此可以将洞看成左括号，兔子看成右括号。那么如何最小化距离之和呢？聪明的同学肯定已经看出来了，但是我们还可以换种方法。

在一个二维平面上，有自左向右延伸的一条折线。折线每经过一个洞可以选择高度加一或者不变，每遇到一个兔子高度必须减一。折线最终的高度必须为 0，且折线不能低于坐标轴。最小化折线下方的面积。

不难发现，上面两种分析方法是等价的，和原问题亦是等价的。

其中第二个思路非常直观，显而易见，我们只需要贪心地让折线尽量不上升即可。当遇到一个兔子，意味着折线在之前必须有一个地方上升，那么贪心选取最靠右的一个即可。

由于我们遇到的洞的位置单调递增，对于每个兔子，为它分配剩余的最靠右的洞即可，因此这个问题已经可以用一遍排序和一个栈解决。

模型 2

一个兔子必须进一个洞，一个洞最多进一个兔子。兔子只能往左走，洞有附加权值。最小化兔子行走的距离及选择的洞的权值之和。

这个问题较上一个问题的不同之处在于附加权值。我们可以建立新的模型描述这个问题，也可以尝试推广上一个模型。

如果去推广上一个模型，我们可以给折线的每次上升和每次下降赋权。令 $x$代表兔子或者洞的位置，$v$代表洞的附加权值，则一个洞 (折线的上升) 的权值可以表示为 $-x_i+v_i$，而一个兔子 (折线的下降) 的权值可以表示为 $x_i$。在合适的地方让折线上升或者下降，就能最小化权值总和。

除了洞的权值不再像模型 1 中那样递增之外，没有任何其它区别。我们只需要一个可以动态维护最小值的数据结构就可以解决。

模型 3

一个兔子必须进一个洞，一个洞最多进一个兔子。兔子可以向两边走，洞有附加权值，最小化兔子行走的距离及选择的洞的权值之和。

这个问题依旧可以用折线法分析，只不过会比较麻烦。我们再试试新的方法，比如匹配。

像上一个模型一样，我们将这些所有的兔子和洞都定义一个权值，做最小权最大匹配。

建立费用流模型。我们依次从每一只兔子开始增广，每一种可能的增广路实际上都对应着一个可以感性理解的事件：

从左往右观察每一只兔子和每一个洞。假设对于所有观察过的兔子和洞，我们都已经机智地按最优策略将它们匹配。由于每只兔子都需要进洞，当我们看到一只兔子，我们可以强行给它一个最好的洞 (如果没有洞的话，假设一开始无穷远处有无数个非常差的洞)。看到一个洞，我们可以考虑用它去替换一个非常差的洞。我们看到一只强势的兔子，它还可以抢之前兔子的洞，让之前的兔子去选择较差的洞，但是只要这么做可以让总权值变小，我们还是可以容忍这种行为的。如果考虑了这三类事件是否发生，我们已经可以保证，再添加了这个新的兔子或洞后，所有东西还是按照最优策略匹配的。

然后，我们再尝试用数字去描述每一种事件。一个兔子，不管它通过什么方式找到了一个洞，这个洞对于它来说不会有任何差别，但是不同的洞对权值和的贡献不一样。甚至，如果这个洞是抢来的，还需要考虑影响到的其它很多兔子匹配权值的变化。但是，我们给这只兔子所有能搞到的洞一个对应着总权值增量的权值，根据费用流的贪心性质，我们当然是选择权值最小的洞。

令 $v_i$为某种方式得到一个洞的权值，$w_i$为某种方式得到一只兔子的权值，$x_i$为兔子的坐标，$y_i$为洞的坐标，$s_i$为一个洞的附加权值。

一只兔子 $b$如果选择洞 $a$，总权值的增加量即为 $v_a+x_b$。之后一个好洞 $c$替换这个坏洞时，总权值又会增加 $y_c-v_a-2x_b$，对于好洞 $c$来说，它找到了一只兔子，并且产生了 $y_c-v_a-2x_b$的贡献，因此我们可以新增加一只权值为 $-v_a-2x_b$的兔子。
一个洞 $b$如果找到了兔子 $a$，总权值的增加量 $w_a+y_b+s_b$。之后一个兔子 $c$抢走了这个洞时，总权值又会增加 $x_c-w_a-2y_b$，对于 $c$来说，它找到了一个洞，而 $a$也不会因此无家可归，因为当我们处理 $a$的时候，我们肯定为它分配了在它前面的洞，后来 $b$找到了 $a$，现在 $b$把 $a$赶走了，$a$显然可以回去找之前分配给它的洞，赶走里面住的兔子，以此类推。这样，一切又回到了 $b$没有发现 $a$时的模样，因此，对于 $c$来说，我们可以新增一个权值为 $-w_a-2y_b$的洞。
一个洞 $b$如果找到了兔子 $a$，总权值增加量 $w_a+y_b+s_b$。之后一个新的洞 $c$替代了 $b$，总权值又会增加 $y_c+s_c-y_b-s_b$，对于 $c$来说，它找到了一个权值为 $-y_b-s_b$的兔子，因此我们新增一个这样的兔子。

这时，兔子已经不在是兔子，洞也已经不再是洞了。洞和兔子因为彼此的利益关系交织在一起，但是无论如何，我们只需要一个堆就可以把它们处理地服服帖帖的。

说了这么多，我们实际上是通过新增 “洞” 和 “兔子” 完成了两者的 “反悔” 操作。

模型 4

兔子和洞都有分身 (即一个位置上可以有多个洞和兔子)，一个兔子必须进一个洞，一个洞最多进一个兔子。兔子可以向两边走，洞有附加权值，最小化兔子行走的距离及选择的洞的权值之和。

如果已经理解了上一个模型，这个模型其实就是在记录权值的同时记录一下数量，对于一大批相同的兔子和洞，批处理完成匹配和反悔操作。同样还是用两个堆去维护这些东西的最小值。

但是，我们还不知道这样会不会因为不停新建新的兔子和洞导致复杂度爆炸。

实际上，如果你保证新建的节点数不比销毁的多，或者每次多的倍数不超过一个有限大的常数 $c$，而且销毁节点的次数为 $O(N)$，根据势能分析，总复杂度还是 $O(cN\log cN)$的。对于模型 4 时间复杂度的具体证明，此处从略。

模型 5

树上的兔子要进树上的洞。一个兔子必须进一个洞，一个洞最多进一个兔子。兔子可以向两边走，最小化兔子行走的距离之和。

在树上，我们依旧需要完成所有的反悔操作。在树上，我们只能自底向上合并子树中的兔子和洞。

这就会有问题，由于每个遇到的兔子在任意时刻都需要有一个匹配的洞，我们就需要为那些无家可归的兔子先分配一个权值为 $+\infty$的洞。这个洞是不能被抢走的，也就是说我们不能将这个洞加入反悔序列内。如果它被抢走了，这只兔子就真的无家可回了。

我们依旧用堆维护子树内的权值最小的兔子和洞，将两棵子树内的兔子和洞完成匹配后，将堆合并即可。

posted @ 2019-04-16 11:54 hehe_54321 阅读(658) 评论(0) 编辑收藏举报

刷新页面返回顶部

哈

233

uoj455 【UER #8】雪灾与外卖

基础模型

变形1.激活传送点

变形2.必须传送掉

变形3.左右都可走

变形4.分身

变形5.分身必须匹配一个

变形6.上树

模拟费用流

简介

模型 1

模型 2

模型 3

模型 4

模型 5

公告