题意
传送门 AOJ 2266
题解
转化为区间覆盖问题的思路
对于全部 m i s s miss miss 的情况,时间 K K K 内所有 a i a_{i} ai 都需要 w a i w_{a_{i}} wai 的花费;最小化花费,则要最大化 h i n t hint hint 的缓存对应的权和;对于一个 h i n t hint hint 的 a i a_{i} ai ,对应的缓存区需要从上一个相同的存入的 a i ′ a_{i'} ai′ 时刻保持不变(即不存入其他 a i ′ ′ a_{i''} ai′′),考虑到每个时刻必有一个内存块缓存,故保持不变的缓存区每个时刻只有 M − 1 M-1 M−1 个;又考虑到相邻的相同内存块,后一个放入前一个缓存的位置总是无花费的。
问题则转化为对序列 a a a 相邻重复元素去重之后,相同的 a i a_{i} ai 与 a i ′ a_{i'} ai′ 对应区间集合,在时间区间 [ 0 , K ) [0,K) [0,K) 每个点最多覆盖 M − 1 M-1 M−1 次的最大权问题;此时求源点、汇点间流量为 M − 1 M-1 M−1 的最小费用流即可。
更一般的思路
这部分参考了前辈思路。缓存查询是时间相关的,考虑权值和在不同时刻(存在不同缓存可能)的状态转移。
各时刻缓存区有无缓存、有缓存两种情况;内存块有存入与不存入两种情况;特别考虑缓存 h i n t hint hint 的情况。可以简化为下面三种情况:存入新内存块;无新内存块存入;时刻 t ′ t' t′ 请求的内存块与当前请求内存块一致。
[ 时刻 t 状态 - (转移次数(
∞
\infty
∞ 代表转移次数由其他条件限制) / 权重) => 时刻 t’ 状态 ]
I
:
v
[
t
]
−
(
1
/
w
[
a
[
t
]
]
)
=
>
v
[
t
+
1
]
\textrm{I}:v[t]-(1/w[a[t]])=>v[t+1]
I:v[t]−(1/w[a[t]])=>v[t+1]
II
:
v
[
t
]
−
(
∞
/
0
)
=
>
v
[
t
+
1
]
\textrm{II}:v[t]-(\infty/0)=>v[t+1]
II:v[t]−(∞/0)=>v[t+1]
III
:
v
[
t
]
−
(
1
/
0
)
=
>
v
[
t
′
]
\textrm{III}:v[t]-(1/0)=>v[t']
III:v[t]−(1/0)=>v[t′]
实际上 III \textrm{III} III 可以看做包含 I \textrm{I} I 的转移
III : v [ t ] − ( 1 / w [ a [ t ] ] ) = > v [ t + 1 ] − ( 1 / − w [ a [ t ] ] ) = > v [ t ′ ] \textrm{III}:v[t]-(1/w[a[t]])=>v[t+1]-(1/-w[a[t]])=>v[t'] III:v[t]−(1/w[a[t]])=>v[t+1]−(1/−w[a[t]])=>v[t′]
对于 I \textrm{I} I,每个时刻一定会状态转移,可以看做流量最小限制为 1 1 1,可以将其预处理后去除
∑ i = 0 K − 1 w [ a [ t ] ] \sum\limits_{i=0}^{K-1}w[a[t]] i=0∑K−1w[a[t]]
于是剩下 2 2 2 种转移,对应建图即可,此时流量为 M − 1 M-1 M−1
II
′
:
v
[
t
]
−
(
∞
/
0
)
=
>
v
[
t
+
1
]
\textrm{II}':v[t]-(\infty/0)=>v[t+1]
II′:v[t]−(∞/0)=>v[t+1]
III
′
:
v
[
t
+
1
]
−
(
1
/
−
w
[
a
[
t
]
]
)
=
>
v
[
t
′
]
\textrm{III}':v[t+1]-(1/-w[a[t]])=>v[t']
III′:v[t+1]−(1/−w[a[t]])=>v[t′]
t ′ = t + 1 t'=t+1 t′=t+1 时出现负圈,可以对连续区间相同元素去重消去负圈;此时答案为
∑ i = 0 K − 1 w [ a [ t ] ] + m i n c o s t f l o w ( s , t , M − 1 ) \sum\limits_{i=0}^{K-1}w[a[t]]+min_cost_flow(s,t,M-1) i=0∑K−1w[a[t]]+mincostflow(s,t,M−1)
代码
两种思路的实现一致。
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#define min(a,b) (((a) < (b)) ? (a) : (b))
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define abs(x) ((x) < 0 ? -(x) : (x))
#define INF 0x3f3f3f3f
#define delta 0.85
#define eps 1e-10
#define PI 3.14159265358979323846
using namespace std;
#define MAX_V 10005
struct edge{
int to, cap, cost, rev;
edge(int to, int cap, int cost, int rev):to(to), cap(cap), cost(cost), rev(rev){}
};
int V;
vector<edge> G[MAX_V];
int h[MAX_V], dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];
bool inq[MAX_V];
void add_edge(int from, int to, int cap, int cost){
G[from].push_back(edge(to, cap, cost, G[to].size()));
G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}
int min_cost_flow(int s, int t, int f){
int res = 0;
memset(h, 0, sizeof(h));
// Spfa 处理负权边
memset(inq, 0, sizeof(inq));
memset(dist, 0x3f, sizeof(dist));
queue<int> q;
dist[s] = 0;
q.push(s);
inq[s] = 1;
while(!q.empty()){
int v = q.front(); q.pop();
inq[v] = 0;
for(int i = 0; i < G[v].size(); i++){
edge &e = G[v][i];
int d2 = dist[v] + e.cost + h[v] - h[e.to];
if(e.cap > 0 && dist[e.to] > d2){
dist[e.to] = d2;
if(!inq[e.to]){
q.push(e.to);
inq[e.to] = 1;
}
}
}
}
for(int v = 0; v < V; v++) h[v] += dist[v];
while(f > 0){
// Dijkstra 连续最短路求最小费用流
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > que;
memset(dist, 0x3f, sizeof(dist));
dist[s] = 0;
que.push(pair<int, int>(0, s));
while(!que.empty()){
pair<int, int> p = que.top(); que.pop();
int v = p.second;
if(dist[v] < p.first) continue;
for(int i = 0; i < G[v].size(); i++){
edge &e = G[v][i];
int d2 = dist[v] + e.cost + h[v] - h[e.to];
if(e.cap > 0 && d2 < dist[e.to]){
dist[e.to] = d2;
prevv[e.to] = v;
preve[e.to] = i;
que.push(pair<int, int>(dist[e.to], e.to));
}
}
}
if(dist[t] == INF){
return -1;
}
for(int v = 0; v < V; v++) h[v] += dist[v];
int d = f;
for(int v = t; v != s; v = prevv[v]){
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for(int v = t; v != s; v = prevv[v]){
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
void clear_graph(){
for(int v = 0; v < V; v++) G[v].clear();
}
#define MAX_K 10000
#define MAX_N 10000
int M, N, K;
int w[MAX_N];
int a[MAX_K], pre[MAX_K];
void solve(){
int res = 0;
memset(pre, -1, sizeof(pre));
// 连续区间相同元素去重
int na = unique(a, a + K) - a;
// 初始化图
int s = na, t = s + 1;
V = t + 1;
clear_graph();
// 建图
add_edge(s, 0, M - 1, 0);
add_edge(na - 1, t, M - 1, 0);
for(int i = 0; i < na - 1; i++){
add_edge(i, i + 1, INF, 0);
}
int cnt = 0;
for(int i = 0; i < na; i++){
if(pre[a[i]] != -1){
add_edge(pre[a[i]] + 1, i, 1, -w[a[i]]);
}
pre[a[i]] = i;
}
// 答案为最坏情况费用加上最小费用流结果
for(int i = 0; i < na; i++) res += w[a[i]];
res += min_cost_flow(s, t, M - 1);
printf("%d\n", res);
}
int main(){
while(~scanf("%d%d%d", &M, &N, &K)){
for(int i = 0; i < N; i++){
scanf("%d", w + i);
}
for(int i = 0; i < K; i++){
scanf("%d", a + i);
--a[i];
}
solve();
}
return 0;
}