Ruler UVA - 1377

最新推荐文章于 2020-12-16 14:23:42 发布

carut

最新推荐文章于 2020-12-16 14:23:42 发布

阅读量128

点赞数

分类专栏： # 白书第一章算法设计基础

本文链接：https://blog.csdn.net/zpf1998/article/details/104934425

版权

白书第一章算法设计基础专栏收录该内容

119 篇文章 0 订阅

订阅专栏

博客分析了UVA在线判题系统中的1377题，即尺子问题。作者指出最短尺子的长度应该等于最大的数字，并采用BFS（广度优先搜索）策略来解决。通过二进制表示状态，利用集合存储不同刻痕，确保不重复。在搜索过程中，由于BFS的特性，先出现的状态代表的解长度更优，因此可以找到子问题的最优解。

摘要由CSDN通过智能技术生成

问题

https://vjudge.net/problem/UVA-1377

分析

https://www.cnblogs.com/bitch1319453/p/5011452.html
https://blog.csdn.net/accelerator_/article/details/18312437?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
前提：直觉上最优解的长度（最短的尺子）就是最大的数字，所以所有的解的长度都大于等于最大值。那么在计算中就剔除大于最大值的解。由于是BFS，每次增加一个没有出现的刻痕，用二进制表示状态（要求的长度是否被标出），使用set存储留下的刻痕。每个状态由二进制代表。
如果两个状态的二进制相同，那么后面出现的刻痕一定不会比前面的少（BFS算法决定的），而且两个状态能够标出的长度又是相同的，根据前面的直觉，这两个解的长度都是大于等于能标出的最大长度的，且能够取到等于号，因为代码先见后加，先看小的，后查看大的数字，所以第一个出现的解的长度更小，是子问题的最优解。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <set>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <unordered_set>
using namespace std;
typedef long long LL;
const int maxn=55,Inf=0x3f3f3f3f;
struct State{
    int s;
    set<int> rule;
    State(){
        s=0;
        rule.insert(0);
    }
};
int n,d[maxn],kase=0,a[maxn],b[maxn],tot,rec[1000005];
set<int> vis;

State solve(){
    queue<State> q;
    q.push(State());
    State ans;
    vis.insert(0);
    while(!q.empty()){
        State temp=q.front();
        q.pop();
        if(temp.s==(1<<n)-1){
            //这地方很关键，只要找到了第一个解，后面的解一定没有第一个好，因为长度相同，而且使用的是BFS，后面的
            //刻度一定比前面的多
            ans=temp;
            return ans;
        }
        for(int i=0;i<n;++i){
            //依此寻找不能表示的长度
            if(temp.s&(1<<i)) continue;
            for(auto iter1=temp.rule.begin();iter1!=temp.rule.end();++iter1){
                if(*iter1>d[i]){
                    int pos=*iter1-d[i];
                    State temp2=temp;
                    temp2.rule.insert(pos);
                    for(auto iter2=temp.rule.begin();iter2!=temp.rule.end();++iter2){
                        if(rec[abs(*iter2-pos)]>0)
                            temp2.s|=(1<<(rec[abs(*iter2-pos)]-1));
                    }
                    if(vis.count(temp2.s)==0) {
                        vis.insert(temp2.s);
                        q.push(temp2);
                    }
                }
                if(*iter1+d[i]<=tot){
                    int pos=*iter1+d[i];
                    State temp2=temp;
                    temp2.rule.insert(pos);
                    for(auto iter2=temp.rule.begin();iter2!=temp.rule.end();++iter2){
                        if(rec[abs(*iter2-pos)]>0)
                            temp2.s|=(1<<(rec[abs(*iter2-pos)]-1));
                    }
                    if(vis.count(temp2.s)==0) {
                        vis.insert(temp2.s);
                        q.push(temp2);
                    }
                }
            }
        }
    }
}

int main(void){
    while(scanf("%d",&n)==1 && n){
        vis.clear();
        for(int i=0;i<n;++i){
            scanf("%d",&d[i]);
        }
        sort(d,d+n);
        //C(7,2)=21,最多表示21种长度，所以肯定有重复的数字
        n=unique(d,d+n)-d;
        for(int i=0;i<n;++i) rec[d[i]]=i+1;
        tot=d[n-1];
        State ans=solve();
        printf("Case %d:\n",++kase);
        printf("%d\n",ans.rule.size());
        for(auto it=ans.rule.begin();it!=ans.rule.end();++it){
            if(it!=ans.rule.begin()) printf(" %d",*it);
            else printf("%d",*it);
        }
        printf("\n");
        for(int i=0;i<n;++i) rec[d[i]]=0;
    }
    return 0;
}