[POJ1180&POJ3709]Batch Scheduling&K-Anonymous Sequence 斜率优化DP

POJ1180 Batch Scheduling

　　Description

　　There is a sequence of N jobs to be processed on one machine. The jobs are numbered from 1 to N, so that the sequence is 1,2,..., N. The sequence of jobs must be partitioned into one or more batches, where each batch consists of consecutive jobs in the sequence. The processing starts at time 0. The batches are handled one by one starting from the first batch as follows. If a batch b contains jobs with smaller numbers than batch c, then batch b is handled before batch c. The jobs in a batch are processed successively on the machine. Immediately after all the jobs in a batch are processed, the machine outputs the results of all the jobs in that batch. The output time of a job j is the time when the batch containing j finishes.

　　A setup time S is needed to set up the machine for each batch. For each job i, we know its cost factor Fi and the time Ti required to process it. If a batch contains the jobs x, x+1,... , x+k, and starts at time t, then the output time of every job in that batch is t + S + (T_x + T_x+1 + ... + T_x+k). Note that the machine outputs the results of all jobs in a batch at the same time. If the output time of job i is Oi, its cost is Oi * Fi. For example, assume that there are 5 jobs, the setup time S = 1, (T1, T2, T3, T4, T5) = (1, 3, 4, 2, 1), and (F1, F2, F3, F4, F5) = (3, 2, 3, 3, 4). If the jobs are partitioned into three batches {1, 2}, {3}, {4, 5}, then the output times (O1, O2, O3, O4, O5) = (5, 5, 10, 14, 14) and the costs of the jobs are (15, 10, 30, 42, 56), respectively. The total cost for a partitioning is the sum of the costs of all jobs. The total cost for the example partitioning above is 153.

　　You are to write a program which, given the batch setup time and a sequence of jobs with their processing times and cost factors, computes the minimum possible total cost.

 

　　看这道题的形式和数据范围，斜率优化其实已经很明显。

　　但是当我们想要写转移的时候却遇到了麻烦...

　　计算当前花费的时候需要用到上一阶段的所用时间

　　且这个所用时间与其花费并没有什么关系

　　要保证正确性只能写一个看起来非常不爽的二维DP

　　我们会想，之前加工的时间会影响到当前从而不好处理，那我们能不能让现在的时间去影响之前的结果呢？

　　答案是肯定的，我们可以将状态反过来定义。用f[i]表示i..n的费用和。

　　　　f[i]=f[j]+(s*t[i]-t[j])*F[i]

　　t[i]表示i..n零件加工时间和，F[i]表示i..n的零件权值和。

　　这样一来，问题就明朗许多了。可以用普通的斜率优化进行。

　　设i<j<k 设此时取j比k好，则列出不等式

　　　　f[j]+(t[i]-t[j])*F[i]<f[k]+(t[i]-t[k])*F[i]

　　化简得

　　　　F[i]>(f[j]-f[k])/(t[j]-t[k]) 

　　这是我们熟悉的斜率表达式。设它为g[j,k]

　　维护一个下凸的单调序列。

　　求解当前答案的时候，我们可以通过g来得知哪些点取来更优

　　很容易发现当维护好序列单调性时，（g[j,k]<F[i]）是满足00000011111的

　　也就是遇到的第一个1的位置时的j就是我们所要求的状态。

　　求解直接按照推出的方程式转移即可。

　　接着我们要把当前点加入，同时维护单调性。

　　

　　代码十分短感觉很优美>_<

 

---

 

program poj1180;
const maxn=;
var i,head,tail,n,s:longint;
    opt,dp,f,t:array[-..maxn]of int64;

function g(x,y:longint):extended;
begin
    exit((dp[x]-dp[y])/(t[x]-t[y]));
end;

begin
    readln(n);
    readln(s);
    for i:= to n do readln(t[i],f[i]);
    for i:=n- downto  do
    begin
        inc(t[i],t[i+]);
        inc(f[i],f[i+]);
    end;
    t[n+]:=;f[n+]:=;
    head:=;tail:=;opt[]:=n+;dp[n+]:=;
    for i:=n downto  do
    begin
        while (head<tail)and(g(opt[head+],opt[head])<f[i]) do inc(head);
        dp[i]:=dp[opt[head]]+(s+t[i]-t[opt[head]])*f[i];
        while (head<tail)and(g(opt[tail],opt[tail-])>g(i,opt[tail])) do dec(tail);
                inc(tail);opt[tail]:=i;
    end;
    writeln(dp[]);
end.

---

POJ3709 K-Anonymous Sequence

　　Description

　　The explosively increasing network data in various application domains has raised privacy concerns for the individuals involved. Recent studies show that simply removing the identities of nodes before publishing the graph/social network data does not guarantee privacy. The structure of the graph itself, along with its basic form the degree of nodes, can reveal the identities of individuals.

　　To address this issue, we study a specific graph-anonymization problem. We call a graph k-anonymous if for every node v, there exist at least k-1 other nodes in the graph with the same degree asv. And we are interested in achieving k-anonymous on a graph with the minimum number of graph-modification operations.

　　We simplify the problem. Pick n nodes out of the entire graph G and list their degrees in ascending order. We define a sequence k-anonymous if for every element s, there exist at least k-1 other elements in the sequence equal to s. To let the given sequence k-anonymous, you could do one operation only—decrease some of the numbers in the sequence. And we define the cost of the modification the sum of the difference of all numbers you modified. e.g. sequence 2, 2, 3, 4, 4, 5, 5, with k=3, can be modified to 2, 2, 2, 4, 4, 4, 4, which satisfy 3-anonymous property and the cost of the modification will be |3-2| + |5-4| + |5-4| = 3.

　　Give a sequence with n numbers in ascending order and k, we want to know the modification with minimal cost among all modifications which adjust the sequence k-anonymous.

 

　　　也是一道斜率优化的拓展题。首先我们可以非常熟练地推出斜率：

　　　　　　g[j,k]=(f[j]-s[j]+j*a[j]-(f[k]-s[k]+k*a[k]))/(a[j]-a[k])

　　　　推的过程大同小异这里就不详细列出了。

　　　　然后转移方程

　　　　f[i]=f[j]+s[i]-s[j]-(i-j)*a[j]

　　　　　　(a[j]=s[j+1])（为了形式更优美我们把下标换成j当然不换也没有什么关系）

　　　　这道题的问题有两个

　　　　其中一个是k要怎么控制？刚开始想了一个并不好的方法就是在求解的时候各种控制但是还要担心缩tail的时候会影响后面的答案...

　　　　其实只要从DP的角度考虑，将i点加入队列无非就是给i以后的点增加一个可转移的状态

　　　　那么只要保证当前在求i的时候，i-k+1..i-1的点不在单调队列里就行了

　　　　自然而然地想到了延迟入队这样问题就迎刃而解了

　　　　

　　　　在上一道题中，保证每个零件的加工时间都是非负整数，因此表示前缀和的t数组数字各不相同

　　　　而这道题不一样，作为分母的a数组可能相同，所以斜率还要特判分母等于0的情况

　　　　刚开始就是这里出了错。返回值要根据分子的符号来决定是正无穷还是负无穷。

program poj3709;
const maxn=;INF=;
var t,test,n,k,head,tail,v,i:longint;
    s,a,opt,f:array[-..maxn]of int64;

function g(x,y:longint):extended;
begin
    if a[x]<>a[y] then exit((f[x]-s[x]+x*a[x]-f[y]+s[y]-y*a[y])/(a[x]-a[y]));
        if (f[x]-s[x]+x*a[x]-f[y]+s[y]-y*a[y])> then exit(INF) else exit(-INF);
    //如果分子是正的就返回正无穷否则返回负无穷
end;

begin
    readln(test);
    for t:= to test do
    begin
        readln(n,k);
        for i:= to n do read(s[i]);s[n+]:=;
        for i:= to n do a[i]:=s[i+];
        for i:= to n do inc(s[i],s[i-]);
        head:=;tail:=;opt[]:=;s[]:=;f[]:=;
            for i:=k to n do
        //这里我控制的目的是不要让<k的无用状态将head移向后面
        begin
            while (head<tail)and(g(opt[head+],opt[head])<i) do inc(head);
            f[i]:=f[opt[head]]+(s[i]-s[opt[head]])-(i-opt[head])*a[opt[head]];
            if i-k+>=k then
            //为下一次作的准备，i+1的时候需要i+1-k的状态。而且显然<k的状态是不能被转移的
            begin
                while (head<tail)and(g(opt[tail],opt[tail-])>g(i-k+,opt[tail])) do dec(tail);
                inc(tail);opt[tail]:=i-k+;
            end;
        end;
        writeln(f[n]);
    end;
end.