2. 程式人生 > >牛客國慶集訓派對Day6 A-Birthday （最小費用流）

牛客國慶集訓派對Day6 A-Birthday （最小費用流）

阿新 • • 發佈：2018-12-13

題目描述

恬恬的生日臨近了。宇揚給她準備了一個蛋糕。 正如往常一樣，宇揚在蛋糕上插了n支蠟燭，並把蛋糕分為m個區域。因為某種原因，他必須把第i根蠟燭插在第ai個區域或第bi個區域。區域之間是不相交的。宇揚在一個區域內同時擺放x支蠟燭就要花費x2的時間。宇揚佈置蛋糕所用的總時間是他在每個區域花的時間的和。 宇揚想快些見到恬恬，你能告訴他佈置蛋糕最少需要多少時間嗎？

輸入描述:

第一行包含兩個整數n，m（1 ≤ n ≤ 50， 2≤ m≤ 50）。
接下來n行，每行兩個整數ai,bi（1 ≤ ai, bi ≤ m）。

輸出描述:

一個整數表示答案。

示例1

輸入

複製

3 3
1 2
1 2
1 2

輸出

複製

5

示例2

輸入

複製

3 3
1 2
2 3
1 3

輸出

複製

3

解題思路：最直接的思路，暴力搜尋，列舉2^50種情況。加上剪枝可過（記錄最小的答案）。另外一種思路，要使的和最小，肯定是要使數字儘可能地平均，因此用優先佇列維護每一個數字，然後不斷地嘗試把最大的那個數字移到其他數字裡去，看看答案會不會減小，然後更新答案。

最好的思路是費用流。

每個蠟燭建一個點。每個區域建一個點

建立一個超級源點連向每一個蠟燭，流量為1，費用為0.

建立一個超級匯點，每一個區域向匯點連邊，記為邊集E，流量為INF，費用初始為1.

每個蠟燭向他的區域連邊，流量為1，費用為0.

我們比較關心邊集E，這裡的邊流量每+1，他的費用都要更新，因此我們每次SPFA後，都要判斷增廣路徑是否經過這個邊集E，然後更新這條邊的費用，反向邊也要更新。

如果不想更新費用，可以對於每一個區域再新建50個節點，每個節點的費用為平方數之差，這樣子直接跑就OK。

新建50個的程式碼

#include <iostream>
#include <string.h>
#include <math.h>
#include <vector>
#include <algorithm>
#include <stdio.h>
#include <queue>
using namespace std;
const int MAXN = 4010;
const int INF = 0x3f3f3f3f;
typedef long long ll;
 
struct edge
{
    int u, v, cap, cost, next;
} e[4 * MAXN];
 
int edge_num;
int head[MAXN];
 
void insert_edge(int u, int v, int cap, int cost)
{
    e[edge_num].u = u;
    e[edge_num].v = v;
    e[edge_num].cap = cap;
    e[edge_num].cost = cost;
    e[edge_num].next = head[u];
    head[u] = edge_num++;
 
    e[edge_num].u = v;
    e[edge_num].v = u;
    e[edge_num].cap = 0;
    //注意這裡
    e[edge_num].cost = -cost;
    //注意這裡
    e[edge_num].next = head[v];
    head[v] = edge_num++;
 
 
 
}
 
int dis[MAXN];
int pre[MAXN];
bool vis[MAXN];
bool spfa(int s, int t)
{
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(pre, -1, sizeof(pre));
 
    dis[s] = 0;
    vis[s] = 1;
    queue<int> que;
    que.push(s);
    while (!que.empty())
    {
        int tp = que.front();
        que.pop();
        vis[tp] = 0;
        for (int i = head[tp]; ~i; i = e[i].next)
        {
            int v = e[i].v;
            int cost = e[i].cost;
 
            if (e[i].cap && dis[v] > dis[tp] + cost)
            {
                dis[v] = dis[tp] + cost;
                pre[v] = i;
                if (!vis[v])
                {
                    vis[v] = 1;
                    que.push(v);
                }
            }
        }
    }
    if (dis[t] == INF)
        return false;
    return true;
}
 
pair<int, int> MCMF(int s, int t)
{
    int maxflow = 0;
    int mincost = 0;
    int minc;
    while (spfa(s, t))
    {
        minc = INF;
        int cost = 0;
        for (int i = pre[t]; ~i; i = pre[e[i].u])
            minc = min(minc, e[i].cap);
        for (int i = pre[t]; ~i; i = pre[e[i].u])
        {
            e[i].cap -= minc;
            e[i ^ 1].cap += minc;
            cost += minc * e[i].cost; //flow*unit cost=total cost
 
        }
        mincost += cost;
        maxflow += minc;
    }
    return make_pair(mincost, maxflow);
}
 
 
 
int tot = 0;
int in[MAXN];
 
int out[MAXN];
 
int ssout[MAXN][51];
 
 
 
int S, SK, T;
 
 
int main()
{
 
    edge_num = 0;
    memset(head, -1, sizeof(head));
    tot = 0;
 
    int N, M;
    scanf("%d%d", &N, &M);
 
    S = ++tot;
 
    for (int i = 1; i <= N; i++)
        in[i] = ++tot;
 
    for (int i = 1; i <= M; i++)
    {
        out[i] = ++tot;
        for(int j=1;j<=50;j++){
            ssout[i][j]=++tot;
        }
    }
    T = ++tot;
 
    int a,b;
    for(int i=1;i<=N;i++){
        scanf("%d%d",&a,&b);
        insert_edge(in[i],out[b],1,0);
        insert_edge(in[i],out[a],1,0);
    }
 
    for(int i=1;i<=M;i++){
        for(int j=1;j<=50;j++){
            insert_edge(out[i],ssout[i][j],1,j*j-(j-1)*(j-1));
        }
    }
 
 
    for(int i=1;i<=N;i++){
        insert_edge(S,in[i],1,0);
    }
 
    for(int i=1;i<=M;i++){
        for(int j=1;j<=50;j++)
        insert_edge(ssout[i][j],T,1,0);
    }
 
    printf("%d\n", MCMF(S, T).first);
 
 
    return 0;
}

修改邊費用的程式碼

#include <iostream>
#include <string.h>
#include <math.h>
#include <vector>
#include <algorithm>
#include <stdio.h>
#include <queue>
using namespace std;
const int MAXN = 4010;
const int INF = 0x3f3f3f3f;
typedef long long ll;
 
struct edge
{
    int u, v, cap, cost, next;
} e[4 * MAXN];
 
int edge_num;
int head[MAXN];
 
int  insert_edge(int u, int v, int cap, int cost)
{
    e[edge_num].u = u;
    e[edge_num].v = v;
    e[edge_num].cap = cap;
    e[edge_num].cost = cost;
    e[edge_num].next = head[u];
    head[u] = edge_num++;
 
    e[edge_num].u = v;
    e[edge_num].v = u;
    e[edge_num].cap = 0;
    //注意這裡
    e[edge_num].cost = -cost;
    //注意這裡
    e[edge_num].next = head[v];
    head[v] = edge_num++;
 
    return edge_num-2;
 
}
int wm[5006];
bool im[MAXN];
bool om[MAXN];
int dis[MAXN];
int pre[MAXN];
bool vis[MAXN];
bool spfa(int s, int t)
{
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(pre, -1, sizeof(pre));
 
    dis[s] = 0;
    vis[s] = 1;
    queue<int> que;
    que.push(s);
    while (!que.empty())
    {
        int tp = que.front();
        que.pop();
        vis[tp] = 0;
        for (int i = head[tp]; ~i; i = e[i].next)
        {
            int v = e[i].v;
            int cost = e[i].cost;
 
            if (e[i].cap && dis[v] > dis[tp] + cost)
            {
                dis[v] = dis[tp] + cost;
                pre[v] = i;
                if (!vis[v])
                {
                    vis[v] = 1;
                    que.push(v);
                }
            }
        }
    }
    if (dis[t] == INF)
        return false;
    return true;
}
 
pair<int, int> MCMF(int s, int t)
{
    int maxflow = 0;
    int mincost = 0;
    int minc;
    while (spfa(s, t))
    {
        minc = INF;
        int cost = 0;
        for (int i = pre[t]; ~i; i = pre[e[i].u])
            minc = min(minc, e[i].cap);
        for (int i = pre[t]; ~i; i = pre[e[i].u])
        {
            e[i].cap -= minc;
            e[i ^ 1].cap += minc;
            cost += minc * e[i].cost; //flow*unit cost=total cost
 
            if(im[i]){
                mincost-=(wm[e[i].cost]-1)*(wm[e[i].cost]-1);
                e[i].cost=(wm[e[i].cost]+1)*(wm[e[i].cost]+1);
            }
 
            if(om[i]){
                mincost+=(wm[-e[i].cost]-1)*(wm[-e[i].cost]-1);
                e[i].cost=-(wm[-e[i].cost]+1)*(wm[-e[i].cost]+1);
            }
 
        }
        mincost += cost;
        maxflow += minc;
    }
    return make_pair(mincost, maxflow);
}
 
 
 
int tot = 0;
int in[MAXN];
 
int out[MAXN];
 
 
 
 
int S, SK, T;
 
 
int main()
{
    for(int j=1;j<5000;j++)
        for(int i=1;i<=50;i++)
            if(i*i==j)
                wm[j]=i;
    edge_num = 0;
    memset(head, -1, sizeof(head));
    tot = 0;
 
    int N, M;
    scanf("%d%d", &N, &M);
 
    S = ++tot;
    for (int i = 1; i <= N; i++)
        in[i] = ++tot;
 
    for (int i = 1; i <= M; i++)
    {
        out[i] = ++tot;
    }
    T = ++tot;
 
    int a,b;
    for(int i=1;i<=N;i++){
        scanf("%d%d",&a,&b);
        insert_edge(in[i],out[b],1,0);
        insert_edge(in[i],out[a],1,0);
    }
 
    for(int i=1;i<=M;i++){
        int ee=insert_edge(out[i],T,N,1);
        im[ee]=1;
        om[ee+1]=1;
    }
 
 
    for(int i=1;i<=N;i++){
        insert_edge(S,in[i],1,0);
    }
 
 
    printf("%d\n", MCMF(S, T).first);
 
 
    return 0;
}

相關推薦

牛客國慶集訓派對Day6 A-Birthday （最小費用流）

題目描述 恬恬的生日臨近了。宇揚給她準備了一個蛋糕。 正如往常一樣，宇揚在蛋糕上插了n支蠟燭，並把蛋糕分為m個區域。因為某種原因，他必須把第i根蠟燭插在第ai個區域或第bi個區域。區域之間是不相交的。宇揚在一個區域內同時擺放x支蠟燭就要花費x2的時間。宇揚佈置蛋糕所用的

牛客國慶集訓派對Day6 A Birthday（拆點網路流）

恬恬的生日臨近了。宇揚給她準備了一個蛋糕。 正如往常一樣，宇揚在蛋糕上插了n支蠟燭，並把蛋糕分為m個區域。因為某種原因，他必須把第i根蠟燭插在第ai個區域或第bi個區域。區域之間是不相交的。宇揚在一個區域內同時擺放x支蠟燭就要花費x2的時間。宇揚佈置蛋糕所用的總時間是他

牛客國慶集訓派對Day6 A Birthday (拆點費用流)

恬恬的生日臨近了。宇揚給她準備了一個蛋糕。 正如往常一樣，宇揚在蛋糕上插了n支蠟燭，並把蛋糕分為m個區域。因為某種原因，他必須把第i根蠟燭插在第ai個區域或第bi個區域。區域之間是不相交的。宇揚在一個區域內同時擺放x支蠟燭就要花費x2的時間。宇揚佈置蛋糕所用的總時間是他

牛客國慶集訓派對Day6 B-Board （思維）

題目描述 恬恬有一個nx n的陣列。她在用這個陣列玩遊戲： 開始時，陣列中每一個元素都是0。 恬恬會做某些操作。在一次操作中，她可以將某一行的所有元素同時加上一個值，也可以將某一列的所有元素同時加

牛客國慶集訓派對Day3 B Tree（樹形dp + 組合計數）

題意有點繞，其實就是讓你求一個點能被多少個點集包含，同時這些點集內的點要相互連通。 首先，簡單來說，如果只是計算一個有根樹中任意一個點被多少個只包含它以及它的子樹的點的點集包含，那麼直接普通的樹上統計的trick就可以搞定。但是現在問題是，點集的點可以是其子

牛客國慶集訓派對Day6 J 最短路

文章目錄 題目 解析 題目 解析 從原圖中扣出來一個樹，然後求LCA的ST表 對於多餘的邊，可以對於每個邊上的點都跑一遍最短路，然後求經過這個點查詢的u,v的最短路 OK! // 以

牛客國慶集訓派對Day2 A 矩陣乘法(思維分塊)

題目連結 題意: 給你兩個矩陣A,B, A是n*p，B是p*m，B是一個只有0，1組成的矩陣，Aij<65536 C=A*B，讓你求出C的裡面所有元素的異或和   解析: 官方的標解是分塊，每8個分一組。 例如對於A，每行行每8個分成一組，對於B，

牛客國慶集訓派對Day1 A思維 C暴力 E貪心 L最短路

A Code： #include <bits/stdc++.h> using namespace std; const int AX = 1e6 + 66; int a[AX] ; map&

牛客國慶集訓派對Day2 A 矩陣乘法（簡單）

你以為評測機跑的慢嗎 那你就大錯特錯啦！ 程式碼是轉的。。。 #include<iostream> #include<cstdio> #include<

牛客國慶集訓派對Day2 A 矩陣乘法

就是讓你做一個矩陣乘法，但是可能暴力做複雜度比較高（不會告訴你暴力也能過）。 題目已經大致告訴你優化的方法了。如果兩個二進位制向量點乘，那麼可以用與運算代替乘法運算，最後統計結果中1的個數。而本題就是讓你實現這個過程。 可以看到，第二個矩陣是一個01矩陣，

牛客國慶集訓派對Day2 A

題目描述 深度學習演算法很大程度上基於矩陣運算。例如神經網路中的全連線，本質上是一個矩陣乘法；而卷積運算也通常是用矩陣乘法來完成的。有一些科研工作者為了讓神經網路的計算更快捷，提出了二值化網路的方法，就是將網路權重壓縮成只用兩種值表示的形式，這樣就可以用一些 trick 加

牛客國慶集訓派對Day3 A Knight

題意：略。 分析：規律題，打了表半天沒找出規律。。。 網友思路： 如果目的點不在第一象限，將其轉化到第一象限，且另m>n 若2*n>m>n     若(n+m)是三的倍數，我可以通過走x個（1,2）和y個（2,1）到達，那麼x+2x+2y+y=n+

牛客國慶集訓派對Day4 A思維 D思維 G公式，規律 I 組合 J模擬

A Code： #include <bits/stdc++.h> #define LL long long using namespace std; int main(){ doubl

牛客國慶集訓派對Day6 H-Mountain(思維)

題解 策略顯然是， 如果當前山後面有比它更高的山， 那麼直接飛向第一個比它高的山，忽略中間的山， 如果後面沒有，就直接走向下一座山，下坡。 如果只這樣想的話，可以ST一下區間最大值，模擬。 這樣對於點i，我們RMQ一下[i+1,n]的最大值， 判斷其

牛客國慶集訓派對Day6 B-Board

題解 ① 假設n=5，有三列被加過，有一行被加過， 那麼我們依次遍歷每一行的最小值， 把行最小值減去，就能恢復行操作。 再依次遍歷每一列的最小值， 把列最小值減去，就能恢復列操作。 考慮，有五列被加過且一行被加過的情形。 那麼，行最小值，就不完全是

牛客國慶集訓派對Day6 I-清明夢超能力者黃YY （樹鏈剖分+區間最值+區間染色）

題目描述 黃YY是一個清明夢超能力者，同時也是一個記憶大師。他能夠輕鬆控制自己在夢中的一切，在醒來之後還能清晰的記得夢中所有的細節，這讓他的朋友們都十分羨慕。 又是一個晚上，黃YY又到了自己的夢中，並且隨手造出了一棵有n個點的樹，樹上每個點有一個初始顏色0。為了讓這棵樹

牛客國慶集訓派對Day6 I 清明夢超能力者黃YY

題意：           中文 思路：          染色部分樹鏈剖分即可          對於倒數第K次染色，轉化為正數第Q次，線段樹維護顏色即可。 程式碼： #include <bits/stdc++.h> using namespace

牛客國慶集訓派對Day6 I 清明夢超能力者黃YY（樹鏈剖分 + 線段樹）

題目大意：中文題面，自行自會~  —，—。 題目思路：題目要求在樹上進行一條鏈的更新操作，很直觀就能想到用樹鏈剖分來做。本題要求的是每個結點倒數第k次被染色時，是被染成了什麼顏色，由於這個k是固定的，所以我們可以用線段樹來維護每個點被更新的次數，維護一條鏈上的節點被更新

牛客國慶集訓派對Day6

題目連結:點選這裡 解題思路: 本題可以理解為前一半是每次都爬到比自己在的更高的山,後一半是每次都下到比自己更低的山. 所以答案就是2*max(a[i]) #include<bit

牛客國慶集訓派對Day2 A 矩陣乘法(思維分塊)

題目連結 題意: 給你兩個矩陣A,B, A是n*p，B是p*m，B是一個只有0，1組成的矩陣，Aij<65536 C=A*B，讓你求出C的裡面所有元素的異或和 解析: 官方的標解是分塊，每8個分一組。 例如對於A，每行行每8個分成一組，對於B，每一列每