P1120 小木棍 ［数据加强版］ 回溯法 终极剪枝

最新推荐文章于 2024-10-07 16:14:28 发布
最新推荐文章于 2024-10-07 16:14:28 发布
阅读量129 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/bxd123/p/10696303.html
版权

 

题目描述

乔治有一些同样长的小木棍，他把这些木棍随意砍成几段，直到每段的长都不超过5050。

现在，他想把小木棍拼接成原来的样子，但是却忘记了自己开始时有多少根木棍和它们的长度。

给出每段小木棍的长度，编程帮他找出原始木棍的最小可能长度。

输入输出格式

输入格式：

 

共二行。

第一行为一个单独的整数N表示砍过以后的小木棍的总数，其中N≤65N≤65

（管理员注：要把超过5050的长度自觉过滤掉，坑了很多人了！）

第二行为NN个用空个隔开的正整数，表示NN根小木棍的长度。

 

输出格式：

 

一个数，表示要求的原始木棍的最小可能长度

 

输入输出样例

输入样例#1：  复制 
9
5 2 1 5 2 1 5 2 1
输出样例#1：  复制 
6

说明

2017/08/05

数据时限修改：

-#17 #20 #22 #27 四组数据时限500ms500ms

-#21 #24 #28 #29 #30五组数据时限1000ms1000ms

其他时限改为200ms200ms（请放心食用）

 

一开始想贪心什么的    肯定是暴力搜索   只管搜就完事了

dfs回溯法

小优化: 27分

#include<bits/stdc++.h>
using namespace std;
//input by bxd
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i>=(b);i--)
#define RI(n) scanf("%d",&(n))
#define RII(n,m) scanf("%d%d",&n,&m)
#define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define RS(s) scanf("%s",s);
#define ll long long
#define REP(i,N)  for(int i=0;i<(N);i++)
#define CLR(A,v)  memset(A,v,sizeof A)
//
#define inf 214748347
#define N  1500+5
int cnt=0;
int sum=0;
int n;
int a[100];
int vis[100];
int minn;
int ok;
void dfs(int tot,int t)
{
    if(ok)return ;
    if(t==0)
    {   ok=1;
        printf("%d\n",minn);
    }
    rep(i,1,cnt)
    if(!vis[i])
    {
        if(tot+a[i]<minn)
        {
            
            vis[i]=1;
            dfs(tot+a[i],t);
            vis[i]=0;
    
        }
        else if(tot+a[i]==minn)
        {
            vis[i]=1;
            dfs(0,t-1);
            vis[i]=0;
        }
    }
}
int main()
{
    int n;
    RI(n);
    rep(i,1,n)
    {
        int x;
        RI(x);
        if(x<=50)
        {
            sum+=x;
            a[++cnt]=x;
        }
    }
    sort(a+1,a+1+cnt);
    for(minn=a[cnt];;minn++)
    {
        if(sum%minn)continue;//剪枝
        n=sum/minn;
        CLR(vis,0);
        ok=0;
        dfs(0,n);
        if(ok)break;
    }
    return 0;
}
View Code

 

二分找最后一个点优化：33分 

#include<bits/stdc++.h>
using namespace std;
//input by bxd
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i>=(b);i--)
#define RI(n) scanf("%d",&(n))
#define RII(n,m) scanf("%d%d",&n,&m)
#define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define RS(s) scanf("%s",s);
#define ll long long
#define REP(i,N)  for(int i=0;i<(N);i++)
#define CLR(A,v)  memset(A,v,sizeof A)
//
#define inf 214748347
#define N  1500+5
int cnt=0;
int sum=0;
int n;
int a[100];
int vis[100];
int minn;
int ok;
void dfs(int tot,int t)
{
    if(ok)return ;
    if(t==0)
    {
        ok=1;
        printf("%d\n",minn);
    }
    
    rep(i,1,cnt)
    if(!vis[i])
    {

        if(tot+a[i]==minn)
        {
            vis[i]=1;
            dfs(0,t-1);
            vis[i]=0;
        }
        else if(tot+a[i]<minn)
        {
            int b=tot+a[i];
            int pos=lower_bound(a+1,a+1+cnt,minn-b)-a;
            while( a[pos]==minn-b&&vis[pos])pos++;
            if(a[pos]==minn-b)
            {
                vis[i]=1;
                vis[pos]=1;
                dfs(0,t-1);
                vis[i]=0;
                vis[pos]=0;
            }
            else
            {
                vis[i]=1;
                dfs(tot+a[i],t);
                vis[i]=0;
            }
        }
    }
}
int main()
{
    int n;
    RI(n);
    rep(i,1,n)
    {
        int x;
        RI(x);
        if(x<=50)
        {
            sum+=x;
            a[++cnt]=x;
        }
    }
    sort(a+1,a+1+cnt);
    for(minn=a[cnt];;minn++)
    {
        if(sum%minn)continue;
        n=sum/minn;
        CLR(vis,0);
        ok=0;
        dfs(0,n);
        if(ok)break;
    }
    return 0;
}
View Code

 

事实证明这个二分没什么用

将大的放在前面更好！！！！！

加一个排序就33了

#include<bits/stdc++.h>
using namespace std;
//input by bxd
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i>=(b);i--)
#define RI(n) scanf("%d",&(n))
#define RII(n,m) scanf("%d%d",&n,&m)
#define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define RS(s) scanf("%s",s);
#define ll long long
#define REP(i,N)  for(int i=0;i<(N);i++)
#define CLR(A,v)  memset(A,v,sizeof A)
//
#define inf 214748347
#define N  1500+5
int cnt=0;
int sum=0;
int n;
int a[100];
int vis[100];
int minn;
int ok;
bool cmp(int a,int b)
{
    return a>b;
}

void dfs(int tot,int t)
{
    if(ok)return ;
    if(t==0)
    {
        ok=1;
        printf("%d\n",minn);
    }


    rep(i,1,cnt)
    if(!vis[i])
    {

        if(tot+a[i]==minn)
        {
            vis[i]=1;
            dfs(0,t-1);
            vis[i]=0;
        }
        else if(tot+a[i]<minn)
        {

                vis[i]=1;
                dfs(tot+a[i],t);
                vis[i]=0;
        }
    }
}
int main()
{
    int n;
    RI(n);
    rep(i,1,n)
    {
        int x;
        RI(x);
        if(x<=50)
        {
            sum+=x;
            a[++cnt]=x;
        }
    }
    sort(a+1,a+1+cnt,cmp);
    for(minn=a[1];;minn++)
    {
        if(sum%minn)continue;
        n=sum/minn;
        CLR(vis,0);
        ok=0;
        dfs(0,n);
        if(ok)break;
    }
    return 0;
}
View Code

 

再对 匹配完成进行小优化?  51分 //帮助头匹配很重要

#include<bits/stdc++.h>
using namespace std;
//input by bxd
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i>=(b);i--)
#define RI(n) scanf("%d",&(n))
#define RII(n,m) scanf("%d%d",&n,&m)
#define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define RS(s) scanf("%s",s);
#define ll long long
#define REP(i,N)  for(int i=0;i<(N);i++)
#define CLR(A,v)  memset(A,v,sizeof A)
//
#define inf 214748347
#define N  1500+5
int cnt=0;
int sum=0;
int n;
int a[100];
int vis[100];
int minn;
int ok;
bool cmp(int a,int b)
{
    return a>b;
}

void dfs(int tot,int t,int cur)
{
    if(ok)return ;
    if(t==0)
    {
        ok=1;
        printf("%d\n",minn);
    }

    int d=minn-tot;
    int L=cur;
    int R=cnt;

    rep(i,1,cnt)
    {
        if(vis[i])continue;
        if(tot+a[i]==minn)
        {
            vis[i]=1;
            int j;
            for( j=1;j<=cnt;j++)
                if(!vis[j])break;
            
            vis[j]=1;
            dfs(a[j],t-1,i);
            vis[j]=0;
            vis[i]=0;
        }
        if(tot+a[i]<minn)
        {
                vis[i]=1;
                dfs(tot+a[i],t,i);
                vis[i]=0;
        }
    }
}
int main()
{
    int n;
    RI(n);
    rep(i,1,n)
    {
        int x;
        RI(x);
        if(x<=50)
        {
            sum+=x;
            a[++cnt]=x;
        }
    }
    sort(a+1,a+1+cnt,cmp);
    for(minn=a[1];;minn++)
    {
        if(sum%minn)continue;
        n=sum/minn;
        CLR(vis,0);
        ok=0;
        dfs(0,n,1);
        if(ok)break;
    }
    return 0;
}
View Code

二分优化： 60

#include<bits/stdc++.h>
using namespace std;
//input by bxd
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i>=(b);i--)
#define RI(n) scanf("%d",&(n))
#define RII(n,m) scanf("%d%d",&n,&m)
#define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define RS(s) scanf("%s",s);
#define ll long long
#define REP(i,N)  for(int i=0;i<(N);i++)
#define CLR(A,v)  memset(A,v,sizeof A)
//
#define inf 214748347
#define N  1500+5
int cnt=0;
int sum=0;
int n;
int a[100];
int vis[100];
int minn;
int ok;
bool cmp(int a,int b)
{
    return a>b;
}

void dfs(int tot,int t,int cur)
{
    if(ok)return ;
    if(tot==minn)
    {
        t--;
        if(t==0)
        {
            ok=1;return;
        }
        int i;
        for( i=1;i<=cnt;i++)
            if(!vis[i])break;
        vis[i]=1;
        dfs(a[i],t,i);
        vis[i]=0;
        if(ok)return;
    }
    int L=cur;
    int R=cnt;
    while(L<R)
    {
        int mid=(L+R)>>1;
        if(a[mid]>minn-tot)L=mid+1;
        else R=mid;
    }
    for(int i=L;i<=cnt;i++)
    {
        if(vis[i])continue;
        if(tot+a[i]<=minn)
        {
            vis[i]=1;
            dfs(tot+a[i],t,i);
            vis[i]=0;
        }
    }
}
int main()
{
    int n;
    RI(n);
    rep(i,1,n)
    {
        int x;
        RI(x);
        if(x<=50)
        {
            sum+=x;
            a[++cnt]=x;
        }
    }
    sort(a+1,a+1+cnt,cmp);
    for(minn=a[1];;minn++)
    {
        if(sum%minn)continue;
        n=sum/minn;
        CLR(vis,0);
        ok=0;
        vis[1]=1;
        dfs(a[1],n,1);
        vis[1]=0;
        if(ok)
        {
            printf("%d\n",minn);break;
        }
    }
    return 0;
}
View Code

加一条小剪枝：69  

 

#include<bits/stdc++.h>
using namespace std;
//input by bxd
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i>=(b);i--)
#define RI(n) scanf("%d",&(n))
#define RII(n,m) scanf("%d%d",&n,&m)
#define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define RS(s) scanf("%s",s);
#define ll long long
#define REP(i,N)  for(int i=0;i<(N);i++)
#define CLR(A,v)  memset(A,v,sizeof A)
//
#define inf 214748347
#define N  1500+5
int cnt=0;
int sum=0;
int n;
int a[100];
int vis[100];
int minn;
int ok;
bool cmp(int a,int b)
{
    return a>b;
}

void dfs(int tot,int t,int cur)
{
    if(ok)return ;
    if(tot==minn)
    {
        t--;
        if(t==0)
        {
            ok=1;return;
        }
        int i;
        for( i=1;i<=cnt;i++)
            if(!vis[i])break;
        vis[i]=1;
        dfs(a[i],t,i);
        vis[i]=0;
        if(ok)return;
    }
    int L=cur;
    int R=cnt;
    while(L<R)
    {
        int mid=(L+R)>>1;
        if(a[mid]>minn-tot)L=mid+1;
        else R=mid;
    }
    
    for(int i=L;i<=cnt;i++)
    {
        if(vis[i])continue;
        if(tot+a[i]<=minn)
        {
            vis[i]=1;
            dfs(tot+a[i],t,i);
            vis[i]=0;
            if(ok)return ;
            if(a[i]==minn-tot)return ;
        }
    }
}
int main()
{
    int n;
    RI(n);
    rep(i,1,n)
    {
        int x;
        RI(x);
        if(x<=50)
        {
            sum+=x;
            a[++cnt]=x;
        }
    }
    sort(a+1,a+1+cnt,cmp);
    for(minn=a[1];;minn++)
    {
        if(sum%minn)continue;
        n=sum/minn;
        CLR(vis,0);
        ok=0;
        vis[1]=1;
        dfs(a[1],n,1);
        vis[1]=0;
        if(ok)
        {
            printf("%d\n",minn);break;
        }
    }
    return 0;
}
View Code

如果当前木棍长度就等于剩余要拼接长度  也就是拼上去正好   那么return  (当然 是放在拼接失败后面 也就是dfs后面）
原理:小的比大的更加灵活

 比如当前缺5    目标正好是5 (且后面还有2 3（如果后面没有23就更不用说了） ）  此时拼上去剩余2，3    如果不行的话 后面肯定会追溯到拼接（2，3)  剩余5   这样更加失败 ！！！！！小的更灵活

 

加上nex数组 终于ac了QAQ

#include<bits/stdc++.h>
using namespace std;
//input by bxd
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define repp(i,a,b) for(int i=(a);i>=(b);i--)
#define RI(n) scanf("%d",&(n))
#define RII(n,m) scanf("%d%d",&n,&m)
#define RIII(n,m,k) scanf("%d%d%d",&n,&m,&k)
#define RS(s) scanf("%s",s);
#define ll long long
#define REP(i,N)  for(int i=0;i<(N);i++)
#define CLR(A,v)  memset(A,v,sizeof A)
//
#define inf 214748347
#define N  1500+5
int cnt=0;
int sum=0;
int n;
int a[100];
int vis[100];
int nex[100];
int minn;
int ok;
bool cmp(int a,int b)
{
    return a>b;
}
void dfs(int tot,int t,int cur)
{
    if(ok)return ;
    if(tot==minn)
    {
        t--;
        if(t==0)
        {
            ok=1;return;
        }
        int i;
        for( i=1;i<=cnt;i++)
            if(!vis[i])break;
        vis[i]=1;
        dfs(a[i],t,i);
        vis[i]=0;
        if(ok)return;
    }
    int L=cur;
    int R=cnt;
    while(L<R)
    {
        int mid=(L+R)>>1;
        if(a[mid]>minn-tot)L=mid+1;
        else R=mid;
    }
    for(int i=L;i<=cnt;i++)
    {
        if(vis[i])continue;
        if(tot+a[i]<=minn)
        {
            vis[i]=1;
            dfs(tot+a[i],t,i);
            vis[i]=0;
            if(ok)return ;
            if(a[i]==minn-tot)return ;
            i=nex[i];
        }
    }
}
int main()
{
    int n;
    RI(n);
    rep(i,1,n)
    {
        int x;
        RI(x);
        if(x<=50)
        {
            sum+=x;
            a[++cnt]=x;
        }
    }
    sort(a+1,a+1+cnt,cmp);

    nex[cnt]=cnt;
    repp(i,cnt-1,1)
    if(a[i]==a[i+1])nex[i]=nex[i+1];
    else nex[i]=i;

    for(minn=a[1];;minn++)
    {
        if(sum%minn)continue;
        n=sum/minn;
        ok=0;
        vis[1]=1;
        dfs(a[1],n,1);
        vis[1]=0;
        if(ok)
        {
            printf("%d\n",minn);break;
        }
    }
    return 0;
}
View Code

 

 

巨佬的做法：

用桶 储存

#include<cstdio>
#include<cstdlib>
const int N = 70 ;
int n , cnt , tot , maxn , minn , tm[ N ] /* 2 */ ; 
void dfs( int res , int sum , int target , int p ) {
    if( res == 0 ) {
        printf("%d", target  );
        exit( 0 );
    }
    if( sum == target ) {
        dfs( res - 1 , 0 , target , maxn );
        return;
    }
    for( int i = p ; i >= minn ; i -- ) { // 2  3 
        if( tm[ i ] && i + sum <= target ) {
            tm[ i ] -- ;
            dfs( res , sum + i , target , i );
            tm[ i ] ++ ;
            if ( sum == 0 || sum + i == target )  //4
                break;
        }
    }
    return;
}
int main() {
    scanf("%d" , &n ) ;
    minn = N ;
    int temp;
    while( n -- ) {
        scanf("%d" , &temp );
        if( temp <= 50 ) {
            cnt ++;
            tm[ temp ] ++;
            tot += temp;
            maxn = maxn > temp ? maxn : temp ;   //1
            minn = minn < temp ? minn : temp ;
        }
    }
    temp = tot >> 1;
    for( int i = maxn ; i <= temp ; i ++ ) {
        if( tot % i == 0 ) {
            dfs( tot / i , 0 , i , maxn );
        }
    }
    printf("%d" , tot );
    return 0;
}
View Code

 

巨佬2做法：

这个居然没什么优化都能过！

using namespace std;
bool cmp(int x,int y)
{
    return x>y;
}
int n,t,sum=0,cnt=0,a[70],res,vis[70],pp;
int dfs(int len,int sta,int now)// dfs(剩下的长度，第几个木棍开始，已经摆好了几组) 
{
    if(now==res)
        return 1;
    if(len==0)
        if(dfs(pp,1,now+1))// 当前这一根已经摆完 剩下的长度应该重新开始 
            return 1;
    for(int j=sta;j<=cnt;j++)
        if(!vis[j]&&a[j]<=len)
        {
            vis[j]=1; // 保证点未被用过 
            if(dfs(len-a[j],j+1,now)) // 搜下一个点 
                return 1;
            vis[j]=0;
            if(len==a[j]||len==pp)// 首先：能运行到这表明最大的a[i]也不能满足条件 然后：如果len==pp 即一组新的木棍 那么以后的也不能满足条件 
                break; // 用了当前木棍后无法拼好  但是剩下的木棍长度还等于当前木棍长度 跳出 
            while(a[j+1]==a[j]) // 当前长度不行 其他长度也不行 
                j++;
        }
    return 0;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&t);
        if(t<=50)
        {
            sum+=t;
            a[++cnt]=t;
        }
    }
    sort(a+1,a+1+cnt,cmp);
    for(int i=a[1];i<=sum;i++)
        if(sum%i==0)
        {
            pp=i; // 全局记录长度 
            res=sum/i;
            if(dfs(i,1,0))
            {
                printf("%d",i);
                return 0;
            }
        }
    return 0;
}
View Code

 

转载于:https://www.cnblogs.com/bxd123/p/10696303.html

weixin_30439031
关注
回溯经典剪枝——小木棍
cjj122的博客
07-25 3192
经典回溯题——小木棍
洛谷P1120 小木棍［数据加强版］(回溯法)
earnMoney的专栏
10-11 833
洛谷P1120 小木棍［数据加强版］(回溯法) 题目描述 乔治有一些同样长的小木棍，他把这些木棍随意砍成几段，直到每段的长都不超过50。 现在，他想把小木棍拼接成原来的样子，但是却忘记了自己开始时有多少根木棍和它们的长度。 给出每段小木棍的长度，编程帮他找出原始木棍的最小可能长度。 输入输出格式 输入格式： 输入文件共有二行。 第一行为一个单独的整数N表示砍过以后的小木棍的总数，其
poj2362(小木棍问题的逆过程)
u012584987的专栏
12-11 1082
Square Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 18880   Accepted: 6549 Description Given a set of sticks of various lengths, is it possible to join th
回溯+剪枝（例题解析）
weixin_44417826的博客
12-08 306
题目 将数组拆分成斐波那契序列 给定一个数字字符串 S，比如 S = “123456579”，我们可以将它分成斐波那契式的序列 [123, 456, 579]。 形式上，斐波那契式序列是一个非负整数列表 F，且满足： 0 <= F[i] <= 2^31 - 1，（也就是说，每个整数都符合 32 位有符号整数类型）； F.length >= 3； 对于所有的0 <= i < F.length - 2，都有 F[i] + F[i+1] = F[i+2] 成立。 另外，请注意，将字
【蓝桥杯】 stick回溯法详解(复杂且需要大量剪枝的子集树)
i6223671的博客
02-29 600
问题描述 　　George took sticks of the same length and cut them randomly until all parts became at most 50 units long. Now he wants to return sticks to the original state, but he forgot how many sticks he ...
洛谷 P1120 小木棍 ［数据加强版］DFS+剪枝
qq_40505473的博客
11-10 336
洛谷 P1120 小木棍 ［数据加强版］ 方法：DFS+剪枝 题目描述 乔治有一些同样长的小木棍，他把这些木棍随意砍成几段，直到每段的长都不超过5050。 现在，他想把小木棍拼接成原来的样子，但是却忘记了自己开始时有多少根木棍和它们的长度。 给出每段小木棍的长度，编程帮他找出原始木棍的最小可能长度。 输入格式 共二行。 第一行为一个单独的整数N表示砍过以后的小木棍的总数，其中N≤6...
【Luogu-P1120】 小木棍 ［数据加强版］
531 の 流 水 线
02-25 282
暴搜 + 毒瘤剪枝。 说说这道花了我三四天才调处来的毒瘤暴搜。 事实证明，该借鉴题解时就要借鉴题解。 不过做完这题之后确实对深搜、优化、剪枝有了更深刻的理解。 题意 给 nnn 个小木棒的长度，求他们最多能拼成的长度相同木棍的长度。 下文为了区分，把短的（用来拼的）叫做（小）木棒，长的（被拼接成的）叫做木棍。 思路 试试我新的思路写法。 1 二分？dp？贪心？似乎都不是。 最后认命地发现它就是一道朴素的暴搜，但却有毒瘤的剪枝。 所以暴搜的大致解法就是： 很明显，我们要先枚举若干根木棍的长度，再拿他来拼接，d
P1120 小木棍 ［数据加强版］ & 1442：【例题3】小木棍
jqsh_的博客
01-16 422
没什么用的题干 题目分析 要自动滤掉大于50的长度… 心中******** 已开启自动过滤 剩下的，纯暴搜： 就是枚举原始木棍长度，然后试着拼 疯狂剪枝 剪枝1：排序，剪枝的根本（正序倒序无所谓，别人都是倒序，就我是正序）+计算木棍长度总和 剪枝2：由于原始木棍一定大于等于当前最大的木棍，所以从当前最大的木棍开始枚举原始木棍长度。枚举到木棍长度总和。（还可以有一个小优化，见代码） 剪枝3：如果搜到答案直接退出 这不是废话吗 剪枝4：感谢排序，如果当前长度的木棍不能搜到答案，那么后面等长的木棍也不行.
洛谷 P1120 小木棍 ［数据加强版 ]
我要吃熊猫
09-06 2969
dfs
P1120 小木棍 ［数据加强版］
Free loop！ 爱上编程！
07-26 498
题目描述： 乔治有一些同样长的小木棍，他把这些木棍随意砍成几段，直到每段的长都不超过 50 。现在，他想把小木棍拼接成原来的样子，但是却忘记了自己开始时有多少根木棍和它们的长度。给出每段小木棍的长度，编程帮他找出原始木棍的最小可能长度。 想法： 首先在读入的时候忽略掉长度大于50的木棍（最重要），顺便还要记录一下最短的木棍和最长的木棍的长度（为之后的运算剪枝），然后按照木棍的长度做一次排序（...
【木棍问题——回溯与分支限界算法（使用C语言解决）】
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
12-10 2205
问题描述 木棍问题 描述 乔治拿来一组等长的木棒，将它们随机地砍断，使得每一节木棍的长度都不超过50个长度单位。然后他又想把这些木棍恢复到为裁截前的状态，但忘记了初始时有多少木棒以及木棒的初始长度。请你设计一个程序，帮助乔治计算木棒的可能最小长度。每一节木棍的长度都用大于零的整数表示。 【输入】 输入包含多组数据，每组数据包括两行。第一行是一个不超过64的整数，表示砍断之后共有多少节木棍。第二行是截断以后，所得到的各节木棍的长度。在最后一组数据之后，是一个零。 【输出】 为每组数据，分别输出原始木棒的可能
常见的回溯算法例题总结
bajin7353的博客
08-07 1万+
例一：火柴棍摆正方形（leetcode 473） 已知一个数组，保存了N个火柴棍，问是否可以使用这N个火柴棍摆成一个正方形？ 思考： 回溯算法如何设计？ 如何设计递归函数，递归的回溯搜素合适返回真，何时返回假？ 普通的回溯搜索是否可以解决该问题，如何让对深度搜索进行优化？ 算法设计： 想象正方形的4条边即4个桶，将每个火柴杆回溯的放置在每个桶中，在放完N个火柴杆后，检...
动态规划算法应用之 切割木棍问题
愿君出走半生，归来时仍是少年
06-04 4946
切割木棍问题 给定一根长度为 n 英尺的木棍和一个价值数组 value[]，数组中的第 i 个元素值 v 代表木棍长长度为 i 时，其价值为 v。现在要求将木棍切割成若干段，使得切割后所有木棍的价值总和最大。例如给定长度为 8 的木棍，对于下图的价值数组，当把它切割成两段长度为 2 和 6 的木棍时，两木棍的价值总和最大，为 22。 而对于同样的长度 8，如果价值数组如下，那么切割成 8 段长度为 1 的木棍时取得最大价值 24=3*8。 分析：先考虑只切割一次的情况，因为切割的位置只有 n
切木棍问题（深搜）
linlinsong—ACM界蒟水！
03-18 2988
问题的描述是这样子的，把长度为m的木棍分成n段，有多少种分的方式。 先 举个例子 5 分为3 段 1 1 3 1 3 1 3 1 1 1 2 2 2 2 1 2 1 2 共6种方法，再给出几组测试样例 19 2 18 19 3 153 16 5 1365 下面附上本题的代码：#include<cstdio> #include<iostream> using na
回溯法与分支限界
热门推荐
松子茶的专栏
11-30 1万+
回溯法解题的一个显著特征是在搜索过程中动态产生问题的解空间。在任何时刻，算法只保存从根结点到当前扩展结点的路径。
算法：回溯+剪枝
weixin_42067304的博客
12-09 3840
回溯算法的定义： 在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。 解空间树：依据待解决问题的特性，用树结构表示问题的解结构、用叶子表
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
Locky136的博客
10-05 489
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
线性结构（四）栈及其代码实现及OJ题
最新发布
m0_74328241的博客
10-07 634
栈也是很重要的一种线性数据结构，注意与操作系统中的栈进行区分，以及合理选择其物理结构。
37 7 D:\86184\Documents\?骞?\【数?萁?构1-1?肯?性?韁P1120 ?∧?棍.cpp [Error] reference to 'next' is ambiguous
08-05
这段代码中出现了一个编译错误，错误信息是"reference to 'next' is ambiguous"。这个错误是由于在代码中存在两个名为'next'的引用，编译器无法确定具体要引用哪一个。为了解决这个问题，可以通过指定引用的作用域来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值