【网络流 && 图论建模 && 最大权闭合子图】 [六省联考 2017] 寿司餐厅

题目描述：

P3749 [六省联考 2017] 寿司餐厅

题目描述

Kiana 最近喜欢到一家非常美味的寿司餐厅用餐。

每天晚上，这家餐厅都会按顺序提供 $n$ 种寿司，第 $i$ 种寿司有一个代号 $a_i$ 和美味度 $d_{i,i}$，不同种类的寿司有可能使用相同的代号。每种寿司的份数都是无限的，Kiana 也可以无限次取寿司来吃，但每种寿司每次只能取一份，且每次取走的寿司必须是按餐厅提供寿司的顺序连续的一段，即 Kiana 可以一次取走第 $1,2$ 种寿司各一份，也可以一次取走第 $2,3$ 种寿司各一份，但不可以一次取走第 $1,3$ 种寿司。

由于餐厅提供的寿司种类繁多，而不同种类的寿司之间相互会有影响：三文鱼寿司和鱿鱼寿司一起吃或许会很棒，但和水果寿司一起吃就可能会肚子痛。因此，Kiana 定义了一个综合美味度 $d_{i,j}(i<j)$，表示在一次取的寿司中，如果包含了餐厅提供的从第 $i$ 份到第 $j$ 份的所有寿司，吃掉这次取的所有寿司后将获得的额外美味度。由于取寿司需要花费一些时间，所以我们认为分两次取来的寿司之间相互不会影响。注意在吃一次取的寿司时，不止一个综合美味度会被累加，比如若 Kiana 一次取走了第 $1,2,3$ 种寿司各一份，除了 $d_{1,3}$ 以外，$d_{1,2},d_{2,3}$ 也会被累加进总美味度中。

神奇的是，Kiana 的美食评判标准是有记忆性的，无论是单种寿司的美味度，还是多种寿司组合起来的综合美味度，在计入 Kiana 的总美味度时都只会被累加一次。比如，若 Kiana 某一次取走了第 $1,2$ 种寿司各一份，另一次取走了第 $2,3$ 种寿司各一份，那么这两次取寿司的总美味度为 $d_{1,1}+d_{2,2}+d_{3,3}+d_{1,2}+d_{2,3}$，其中 $d_{2,2}$ 只会计算一次。

奇怪的是，这家寿司餐厅的收费标准很不同寻常。具体来说，如果 Kiana 一共吃过了 $c(c>0)$ 种代号为 $x$ 的寿司，则她需要为这些寿司付出 $m{x}^2+cx$ 元钱，其中 $m$ 是餐厅给出的一个常数。

现在 Kiana 想知道，在这家餐厅吃寿司，自己能获得的总美味度（包括所有吃掉的单种寿司的美味度和所有被累加的综合美味度）减去花费的总钱数的最大值是多少。由于她不会算，所以希望由你告诉她。

输入格式

第一行包含两个正整数 $n,m$，分别表示这家餐厅提供的寿司总数和计算寿司价格中使用的常数。
第二行包含 $n$ 个正整数，其中第 $k$ 个数 $a_k$ 表示第 $k$ 份寿司的代号。
接下来 $n$ 行，第 $i$ 行包含 $n-i+1$ 个整数，其中第 $j$ 个数 $d_{i,i+j-1}$ 表示吃掉寿司能获得的相应的美味度，具体含义见问题描述。

输出格式

输出共一行包含一个正整数，表示 Kiana 能获得的总美味度减去花费的总钱数的最大值。

输入输出样例 #1

输入 #1

3 1
2 3 2
5 -10 15
-10 15
15

输出 #1

12

输入输出样例 #2

输入 #2

5 0
1 4 1 3 4
50 99 8 -39 30
68 27 -75 -32
70 24 72
-10 81
-95

输出 #2

381

输入输出样例 #3

输入 #3

10 1
5 5 4 4 1 2 5 1 5 3
83 91 72 29 22 -5 57 -14 -36 -3
-11 34 45 96 32 73 -1 0 29
-48 68 44 -5 96 66 17 74
88 47 69 -9 2 25 -49
86 -9 -77 62 -10 -30
2 40 95 -74 46
49 -52 2 -51
-55 50 -44
72 22
-68

输出 #3

1223

说明/提示

样例解释 1

在这组样例中，餐厅一共提供了 $3$ 份寿司，它们的代号依次为 $a_1=2,a_2=3,a_3=2$，计算价格时的常数 $m=1$。

在保证每次取寿司都能获得新的美味度的前提下，Kiana 一共有 $14$ 种不同的吃寿司方案。以下列出其中几种：

在 $14$ 种方案中，惟一的最优方案是列出的最后一种方案，这时她获得的总美味度减去花费的总钱数的值最大为 $12$。

数据范围

对于所有数据，保证 $-500\le d_{i,j}\le 500$。

数据的一些特殊约定如下表：

在读题的过程中，我们不难发现题目中的几个量之间存在依赖关系，且这些依赖关系构成了一张最大权闭合子图，再结合题目给的数据范围，我们不难想到这道题可以利用网络流去解决。

最大权闭合子图在网络流中是一个常见的模型：
有若干个物品，每种物品有一个可正可负的价值 $v$ ，选取了物品就意味着获得了价值。
物品之间有限制关系：$x\to y$ 表示若要选择物品 $x$ 则必须选择物品 $y$
对于这类问题，我们考虑用最小割去解决：
我们有源点s，汇点t。 源点向每个点都建边，每个点都向汇点建边。若割掉源点的边则认为不选当前点，若割掉当前点向汇点的连边则认为选择当前点。
那么具体连边要怎么连呢？
如果当前点的价值v为正数，那么让答案加上当前点的价值，并且让当前点和源点连容量为v的边
如果当前点的价值v为负数，那么让当前点和汇点连容量为-v的边。
最小割就是在这个最大权闭合子图上的最大流。

那么答案就是$ans-maxflow$

好，那么回归这个题。
我们将每一个$d_{i,j}$都看做一个点，价值就是他本身的值。
且这些点根点之间都有依赖关系：若想选$d_{i,j}$，就必须选$d_{i,j-1}$和$d_{i+1,j}$
只需要让当前点向这两个点连容量为正无穷的边即可。
同时这个题还有一个寿司种类的限制，想要处理这个限制，最好的办法就是把寿司种类也加入这个图中，且他的价值为$-m\ast a[i]\ast a[i]$
他跟$d_{i,i}$存在限制：$d_{i,i}->a[i]$
且我们没选一个寿司就要扣除他种类编号的价值，也就是令$d_{i,i}$的价值再减去$a[i]$
在这张图上跑最大流即可求出答案。

#include<bits/stdc++.h>
using namespace std;

const int N = 1e4+100,inf = 1e9+100;
struct Node{
int y,Next,v;
}e[100*N];
int len = 1,Linkk[N];
int n,m;
int a[N],d[1000][1000];
int id[1000][1000],idx[10*N];
int ans = 0,cnt = 0;
int st,ed;
map < int , int > M;

void Insert(int x,int y,int v){
e[++len] = (Node){y,Linkk[x],v};
Linkk[x] = len;
e[++len] = (Node){x,Linkk[y],0};
Linkk[y] = len;
}

int de[N];

bool bfs(){
queue < int > q;
for (int i = 1; i <= n; i++) de[i] = 0;
de[st] = 1; q.push(st);
while (q.size()){
int x = q.front(); q.pop();
for (int i = Linkk[x]; i; i = e[i].Next){
int y = e[i].y;
if (de[y] || e[i].v == 0) continue;
de[y] = de[x]+1;
if (y == ed) return 1;
q.push(y);
}
}
return 0;
}

int dinic(int x,int re){
if (x == ed) return re;
int now = re;
for (int i = Linkk[x]; i && re; i = e[i].Next){
int y = e[i].y;
if (e[i].v == 0 || de[y] != de[x]+1) continue;
int k = dinic(y,min(e[i].v,re));
if (k == 0) de[y] = 0;
re-=k;
e[i].v-=k; e[i^1].v+=k;
}
return now–re;
}

void Work(){
len = 1;
cin>>n>>m;
st = ++cnt; ed = ++cnt;
for (int i = 1; i <= n; i++){
cin>>a[i];
if (!M[a[i]]) M[a[i]] = 1 , idx[a[i]] = ++cnt;
}
M.clear();
for (int i = 1; i <= n; i++){
if (M[a[i]]) continue;
M[a[i]] = 1;
if (m) Insert(idx[a[i]],ed,m*a[i]*a[i]);
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++){
cin>>d[i][j],id[i][j] = ++cnt;
int v = d[i][j];
if (i == j){
v = v–a[i];
if (m) Insert(id[i][j],idx[a[i]],inf);
}
if (v > 0){
ans+=v;
Insert(st,id[i][j],v);
}
else Insert(id[i][j],ed,–v);
}
for (int i = 1; i <= n; i++)
for (int j = i+1; j <= n; j++){
int x = id[i][j] ,y ;
if (i + 1 <= n) y = id[i+1][j],Insert(x,y,inf);
y = id[i][j–1]; Insert(x,y,inf);
}
int maxf = 0;
n = cnt;
while (bfs()) maxf+=dinic(st,inf);
cout<<ans–maxf<<endl;
return;
}

int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int _ = 1; while (_—) Work();
return 0;
}