1044: [HAOI2008]木棍分割

1044: [HAOI2008]木棍分割

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 2161  Solved: 779
[Submit][Status][Discuss]

Description

有n根木棍, 第i根木棍的长度为Li,n根木棍依次连结了一起, 总共有n-1个连接处. 现在允许你最多砍断m个连接处, 砍完后n根木棍被分成了很多段,要求满足总长度最大的一段长度最小, 并且输出有多少种砍的方法使得总长度最大的一段长度最小. 并将结果mod 10007。。。

Input

输入文件第一行有2个数n,m. 接下来n行每行一个正整数Li,表示第i根木棍的长度.

Output

输出有2个数, 第一个数是总长度最大的一段的长度最小值, 第二个数是有多少种砍的方法使得满足条件.

Sample Input

3 2
1
1
10

Sample Output

10 2

HINT

两种砍的方法: (1)(1)(10)和(1 1)(10)
数据范围  
   n<=50000, 0<=m<=min(n-1,1000).
   1<=Li<=1000.

解析：

　　第一问：给定N个木棒，要求截[1,M]次，问在所有情况中最长的那个木棒的最小值是多少。再输出情况个数。

　  很显然，若 设截的次数为因变量x，截成之后的最长木棒的长度是y，(0<=x<=M；max(L[i])<y<∑L[i])可以看出 y随着x的上升而下降，是个单调函数(非严格单减)，所以我们可以二分答案，二分y的取值，判断若在此y下求的最少截的次数若小于M，则可行，继续二分，不行，也继续二分，知道精确到一个值即为所求(一般问最大中的最小或最小中的最大都是用二分答案来做的)。

　　二分答案还有一些容易晕的地方，比如这道题中，要求断开的是连接点，不是任意一处去断，可能会有疑问：如果仅仅是从[max,∑]之间二分，中间有很多数字是这些相邻木棒组不成的长度，有没有可能会算出这些数，导致WA呢？其实是不可能的，比如，假设二分枚举到的答案是X1，而真正答案是X2，且X2<X1,那么就说明有分M次，最大长度是X2，当确定X1可以是，我们的程序保证了继续二分，逼近X2这个正确解。因此，裸的二分可行。

　　二分时有一些细节，比如可能会陷入死循环，对于这点，每个人的方法都不大一样，自己注意下。

#include<bits/stdc++.h>
using namespace std;
const int mod=10007;
const int inf=1e9;
int ans1,ans2;
int N,M;
int MAXX,MINN=inf;
int L[50005];//记录原序列 
int sum[50005];//原序列前缀和
void find(int,int);
bool jud(int);
int main(){
    scanf("%d%d",&N,&M);
    for(int i=1;i<=N;i++){
        scanf("%d",&L[i]);
        sum[i]=sum[i-1]+L[i];
        MAXX=max(MAXX,L[i]);
    }
    find(MAXX,sum[N]);
    
    return 0;
}
void find(int l,int r){
    if(r-l<=1){
        if(r==l+1){
            if(jud(l)==true){
                ans1=l;
                cout<<l<<endl;
                return ;
            }
            else{
                ans1=r;
                cout<<r<<endl;
                return ;
            }
        }
        if(l==r){
            ans1=l;
            cout<<l<<endl;
            return ;
        }
    }
    int mid=(l+r)>>1;
    if(jud(mid)==true){
        find(l,mid);
    }
    else{
        find(mid+1,r);
    }
}
bool jud(int x){//当最长木棒为x时 
    int tot=0;
    int pos=0;
    for(int i=1;i<=N-1;i++){//枚举每一条木棒，不用枚举最后一个，因为它后面本来就是断的 
        if(sum[i]-sum[pos]<=x&&sum[i+1]-sum[pos]>x){
            pos=i; 
            tot++;
        }
    }
    if(tot<=M)
        return true;
    else
        return false;
}

　　第二问：在第一问的基础上求出情况个数，第一印象就是dp，暴力如下：

int f[50005][1005];//f[i][j]表示前i个木棒，用j次切割，保证每一段都小于等于ans1的情况个数，f[i][j]=∑f[k][j-1] 
for(int i=1;i<=N;i++){
    for(int j=1;j<=M;j++){
        for(int k=1;k<=i-1;k++){
            if(sum[i]-sum[k]<=ans1){
                f[i][j]=(f[i][j]+f[k][j-1])%mod;
            }
        }
    }
} 

　　呵呵了，时间空间都过不去,空间复杂度为 O(nm) ，时间复杂度为 O(n^2 m)。DP优化才是出题人最主要的目的。

　　首先先说空间上，由于状态转移方程为： f[i][j] = Σ f[k][j-1] ((1 <= k <= i-1) &&  (Sum[i] - Sum[k] <= ans1))，所以第二维空间 j 只和 j-1 有关，就用滚动数组滚动储存就好了，f[i][Now] 代替了 f[i][j] ， f[i][Now^1] 代替了 f[i][j-1] 。为了方便，我们把 f[][Now^1] 叫做 f[][Last] 。位运算异或1的目的是相互转化。这样空间复杂度为 O(n) 。满足空间限制。

　　然后是时间上的，考虑优化状态转移的过程。对于 f[i][Now] ，其实是 f[mink][Last]...f[i-1][Last] 这一段 f[k][Last] 的和，mink 是满足 Sum[i] - Sum[k] <= Len 的最小的 k ，那么，对于从 1 到 n 枚举的 i ，相对应的 mink 也一定是非递减的（因为 Sum[i] 是递增的）。我们记录下 f[1][Last]...f[i-1][Last] 的和 Sumf ，mink 初始设为 1，每次对于 i 将 mink 向后推移，推移的同时将被舍弃的 p 对应的 f[p][Last] 从 Sumf 中减去。那么 f[i][Now] 就是 Sumf 的值。这样时间复杂度为 O(nm) 。满足时间限制。

#include<bits/stdc++.h>
using namespace std;
const int mod=10007;
const int inf=1e9;
int ans1,ans2;
int N,M;
int Minf;
int Sumf;
int MAXX,MINN=inf;
int L[50005];
int sum[50005];
int f[50005][10];
void find(int,int);
bool jud(int);
int main(){
    scanf("%d%d",&N,&M);
    for(int i=1;i<=N;i++){
        scanf("%d",&L[i]);
        sum[i]=sum[i-1]+L[i];
        MAXX=max(MAXX,L[i]);
    }
    find(MAXX,sum[N]);//二分

24　　//-------DP-------------------------------------------
    int Now=0,Last=1,Mink;
    for(int i=0;i<=M;i++){
        Sumf=0;
        Mink=1;
        for(int j=1;j<=N;j++){
            if(i==0){
                if(sum[j]<=ans1)
                    f[j][Now]=1;
                else
                     f[j][Now]=0;
            }
            else{
                while(Mink<j&&sum[j]-sum[Mink]>ans1){
                    Sumf-=f[Mink][Last];
                    Sumf=(Sumf+mod)%mod;
                    ++Mink;
                }
                f[j][Now]=Sumf;
            }
            Sumf+=f[j][Last];
            Sumf%=mod;
        }
        ans2+=f[N][Now];
        ans2%=mod;
        Now^=1;
           Last =Now^1;
    }
    printf("%d", ans2);
    return 0;
}
void find(int l,int r){
    if(r-l<=1){
        if(r==l+1){
            if(jud(l)==true){
                ans1=l;
                cout<<l<<" ";
                return ;
            }
            else{
                ans1=r;
                cout<<r<<" ";
                return ;
            }
        }
        if(l==r){
            ans1=l;
            cout<<l<<" ";
            return ;
        }
    }
    int mid=(l+r)>>1;
    if(jud(mid)==true){
        find(l,mid);
    }
    else{
        find(mid+1,r);
    }
}
bool jud(int x){
    int tot=0;
    int pos=0;
    for(int i=1;i<=N-1;i++){
        if(sum[i]-sum[pos]<=x&&sum[i+1]-sum[pos]>x){
            pos=i; 
            tot++;
        }
    }
    if(tot<=M)
        return true;
    else
        return false;
}