UVa 129 Krypton Factor

注意输出格式,比较坑爹。

每次要进行处理去掉容易的串,统计困难串的个数。

#include<iostream>
#include<vector>
#include<cmath>
#include<map>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<string>
#define INF 1000000000LL
#define ll long long
using namespace std;
];
int cnt,K,L;
bool check(int len)
{
    int l=strlen(str);
    ||l==) return false;
    ; i<=len/; ++i)
    {
        bool ok=true;
        ; j<i&&ok; ++j)
        {
            -j]!=str[len--i-j])
                ok=false;
        }
        if(ok) return true;
    }
    return false;
}
void dfs(int pos)
{
    if(cnt>=K) return ;
    else
    {
        ; i<L; ++i)
        {
            str[pos]='A'+i;
            str[pos+]=;
            )) cnt++;
            else continue ;
            dfs(pos+);
            if(cnt>=K) return ;
        }
    }
}
int main()
{
    while(scanf("%d%d",&K,&L)!=EOF)
    {
        if(!K&&!L) break;
        cnt=;
        dfs();
        int L=strlen(str);
        ; str[i]; ++i)
        {
            ==&&i%) putchar(' ');
            putchar(str[i]);
            )%==) putchar('\n');
        }
        ) putchar('\n');
        printf("%d\n",L);
    }
    ;
}

SPOJ COMCB  1003

注意棋盘方格总数不会超过26。所以可以尝试dfs回溯寻找最优解。

怎么找字典序最小的,这个把棋盘画出来,然后指定一下每次跳的方向的顺序就行。如果第一个跳完全部棋盘的就是最优解。

这里要求输出最优解,每个位置是二维的,可以把它们压缩成一维,开一个数组,下标存第几步,内容存位置,这样就方便储存了。

实际上可行解并不多,可以打表。


HDU 4848 Wow! Such Conquering!

首先用fylod求最短路,然后搜索。时间复杂度大约是30!。肯定要剪枝。

有两个剪枝,一个是如果当前时刻有星球永远无法到达,则return,另一个是如果到该星球以后的时间花费比当前最优解要小则剪枝。这样就能过了。

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define inf 100000000
using namespace std;
][],tim[];
int n;
int ans;
];
void dfs(int now,int rest,int all,int sum)
{
    if(all>=ans) return ;
    )
    {
        ans=min(ans,all);
        return ;
    }
    ; i<n; ++i)
        if((!vis[i])&&(sum+dist[now][i]>tim[i]))
            return;
    ; i<n; ++i)
    {
        if(!vis[i])
        {
            int time=sum+dist[now][i];
            if(time<=tim[i])
            {
                if(ans<=all+rest*time) continue;
                vis[i]=true;
                dfs(i,rest-,all+time,time);
                vis[i]=false;
            }
        }
    }
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        ; i<n; ++i)
            ; j<n; ++j)
            {
                scanf("%d",&dist[i][j]);
            }
        ; k<n; ++k)
            ; i<n; ++i)
                ; j<n; ++j)
                    dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
        ; i<n; ++i)
        {
            scanf("%d",&tim[i]);
        }
        ans=inf;
        memset(vis,,sizeof(vis));
        vis[]=true;
        dfs(,n-,,);
        if(ans==inf) puts("-1");
        else printf("%d\n",ans);
    }
    ;
}

SGU 125  Shtirlits

给一个矩阵B,每个元素B[i][j]表示A[i][j]上下左右四周有多少个数大于自身。输出一个可能的矩阵A。

由于n<=3,完全可以暴力搜索解决。但是9^9肯定会超时的,考虑剪枝。对于每个A[i][j]枚举可能的元素,当枚举到第二行以上的时候,该元素上面的一个元素四周的元素都已经确定了,可以判断是否满足题意,不满足则剪枝。当枚举到最后一行的时候,还可以判断左边的元素是否满足题意。当所有元素都枚举完毕,要进行一次全体的判断,如果符合就是答案。

之前想到一个剪枝,以为每次枚举A[i][j],可以从0枚举到9-B[i][j]。其实这是不对的,因为比A[i][j]大的元素可能是相同的。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
][];
][];
int n;
bool judge(int x,int y)
{
    <=x&&x<n&&<=y&&y<n;
}
][]= {{-,},{,-},{,},{,}};
bool check(int x,int y)
{
    ;
    ; i<; ++i)
    {
        ],ny=y+Move[i][];
        if(judge(nx,ny))
        {
            if(A[x][y]<A[nx][ny])
                cnt++;
        }
    }
    return cnt==B[x][y];
}
bool dfs(int cur)
{
    if(cur==n*n)
    {
         ;i<n;++i)
            ;j<n;++j)
            if(!check(i,j)) return false;
         return true;
    }
    const int x=cur/n,y=cur%n;
    ; i<=; ++i)
    {
        A[x][y]=i;
        &&!check(x-,y))||(x==n-&&y>=&&!check(x,y-)))
            continue;
        ))
            return true;
    }
    return false;
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        ; i<n; ++i)
            ; j<n; ++j)
                scanf("%d",&B[i][j]);
        ))
            puts("NO SOLUTION");
        else
        {
            ; i<n; ++i)
            {
                ; j<n; ++j)
                    if(!j) printf("%d",A[i][j]);
                    else printf(" %d",A[i][j]);
                printf("\n");
            }
        }
    }
    ;
}

POJ 2676 Sudoku

简单数独。用一个剪枝,每次填该行该列该块未出现的数字,可以AC。

倒着搜索用时更少。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cmath>
#include<vector>
#define INF 1000000000
#define LL long long
#define MAXN 100005
using namespace std;
][];
][];
][],visrow[][],visblock[][];
void init()
{
    memset(grid,,sizeof(grid));
    memset(zero,,sizeof(zero));
    memset(viscol,,sizeof(viscol));
    memset(visrow,,sizeof(visrow));
    memset(visblock,,sizeof(visblock));
}
bool dfs(int cur)
{
    ) return true;
    ,y=cur%,num=(x/*)+(y/);
    );
    ; i<=; ++i)
        if(!visrow[x][i]&&!viscol[y][i]&&!visblock[num][i])
        {
            visrow[x][i]=viscol[y][i]=visblock[num][i]=true;
            grid[x][y]=i;
            )) return true;
            visrow[x][i]=viscol[y][i]=visblock[num][i]=false;
        }
    return false;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
        ; i<; ++i)
        {
            ];
            scanf("%s",str);
            ; str[j]; ++j)
            {
                grid[i][j]=str[j]-';
                if(!grid[i][j])
                    zero[i][j]=true;
            }
        }
        ; i<; ++i)
        {
            ; j<; ++j)
            {
                viscol[j][grid[i][j]]=true;
                visrow[i][grid[i][j]]=true;
                visblock[(i/*)+(j/)][grid[i][j]]=true;
            }
        }
        dfs();
        ; i<; ++i)
        {
            ; j<; ++j)
                printf("%d",grid[i][j]);
            printf("\n");
        }
    }
    ;
}

POJ 2918 Tudoku

同POJ2676

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cmath>
#include<vector>
#define INF 1000000000
#define LL long long
#define MAXN 100005
using namespace std;
][];
][];
][],visrow[][],visblock[][];
void init()
{
    memset(grid,,sizeof(grid));
    memset(zero,,sizeof(zero));
    memset(viscol,,sizeof(viscol));
    memset(visrow,,sizeof(visrow));
    memset(visblock,,sizeof(visblock));
}
bool dfs(int cur)
{
    ) return true;
    ,y=cur%,num=(x/*)+(y/);
    );
    ; i<=; ++i)
        if(!visrow[x][i]&&!viscol[y][i]&&!visblock[num][i])
        {
            visrow[x][i]=viscol[y][i]=visblock[num][i]=true;
            grid[x][y]=i;
            )) return true;
            visrow[x][i]=viscol[y][i]=visblock[num][i]=false;
        }
    return false;
}
int main()
{
    ;
    scanf("%d",&T);
    while(T--)
    {
        init();
        ; i<; ++i)
        {
            ];
            scanf("%s",str);
            ; str[j]; ++j)
            {
                grid[i][j]=str[j]-';
                if(!grid[i][j])
                    zero[i][j]=true;
            }
        }
        ; i<; ++i)
        {
            ; j<; ++j)
            {
                viscol[j][grid[i][j]]=true;
                visrow[i][grid[i][j]]=true;
                visblock[(i/*)+(j/)][grid[i][j]]=true;
            }
        }
        dfs();
        printf("Scenario #%d:\n",++kase);
        ; i<; ++i)
        {
            ; j<; ++j)
                printf("%d",grid[i][j]);
            printf("\n");
        }
        if(T) printf("\n");
    }
    ;
}

UVa 989  Su Doku

注意判断无解的情况。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cmath>
#include<vector>
#define INF 1000000000
#define LL long long
#define MAXN 100005
using namespace std;
][];
][];
][],visrow[][],visblock[][];
void init()
{
    memset(grid,,sizeof(grid));
    memset(zero,,sizeof(zero));
    memset(viscol,,sizeof(viscol));
    memset(visrow,,sizeof(visrow));
    memset(visblock,,sizeof(visblock));
}
int n,N;
bool dfs(int cur)
{
    if(cur==N*N) return true;
    int x=cur/N,y=cur%N,num=(x/n*n)+(y/n);
    );
    ; i<=N; ++i)
        if(!visrow[x][i]&&!viscol[y][i]&&!visblock[num][i])
        {
            visrow[x][i]=viscol[y][i]=visblock[num][i]=true;
            grid[x][y]=i;
            )) return true;
            visrow[x][i]=viscol[y][i]=visblock[num][i]=false;
        }
    return false;
}
int main()
{
    ;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        N=n*n;
        if(kase)printf("\n");
        ; i<N; ++i)
        {
            ; j<N; ++j)
            {
                scanf("%d",&grid[i][j]);
                if(!grid[i][j])
                    zero[i][j]=true;
            }
        }
        ; i<N; ++i)
        {
            ; j<N; ++j)
            {
                viscol[j][grid[i][j]]++;
                visrow[i][grid[i][j]]++;
                visblock[(i/n*n)+(j/n)][grid[i][j]]++;
            }
        }
        bool ok=true;
        ; i<&&ok; ++i)
            ; j<=&&ok; ++j)
                ||visrow[i][j]>=||visblock[i][j]>=)
                    ok=false;
        ))
        {
            puts("NO SOLUTION");
        }
        else
        {
            ; i<N; ++i)
            {
                ; j<N; ++j)
                    if(!j) printf("%d",grid[i][j]);
                    else printf(" %d",grid[i][j]);
                printf("\n");
            }
        }
        kase=;
    }
    ;
}

ACM 暴力搜索题 题目整理的更多相关文章

  1. bnuoj 33656 J. C.S.I.: P15(图形搜索题)

    http://www.bnuoj.com/bnuoj/problem_show.php?pid=33656 [题解]:暴力搜索题 [code]: #include <iostream> # ...

  2. hdu 4740 The Donkey of Gui Zhou(暴力搜索)

    题目地址:http://acm.hdu.edu.cn/showproblem.php?pid=4740 [题意]: 森林里有一只驴和一只老虎,驴和老虎互相从来都没有见过,各自自己走过的地方不能走第二次 ...

  3. Noip往年题目整理

    Noip往年题目整理 张炳琪 一.历年题目 按时间倒序排序 年份 T1知识点 T2知识点 T3知识点 得分 总体 2016day1 模拟 Lca,树上差分 期望dp 144 挺难的一套题目,偏思维难度 ...

  4. NOIP2010提高组真题部分整理(没有关押罪犯)

    目录 \(NOIP2010\)提高组真题部分整理 \(T1\)机器翻译: 题目背景: 题目描述: 输入输出格式: 输入输出样例: 说明: 题解: 代码: \(T2\)乌龟棋 题目背景: 题目描述: 输 ...

  5. 2013 ACM网络搜索与数据挖掘国际会议

    ACM网络搜索与数据挖掘国际会议" title="2013 ACM网络搜索与数据挖掘国际会议"> 编者按:ACM网络搜索与数据挖掘国际会议(6th ACM Conf ...

  6. 「浙江理工大学ACM入队200题系列」问题 J: 零基础学C/C++83——宁宁的奥数路

    本题是浙江理工大学ACM入队200题第八套中的J题 我们先来看一下这题的题面. 题面 题目描述 宁宁参加奥数班,他遇到的第一个问题是这样的:口口口+口口口=口口口,宁宁需要将1~9 九个数分别填进对应 ...

  7. 「浙江理工大学ACM入队200题系列」问题 A: 零基础学C/C++34—— 3个数比较大小(冒泡排序与选择排序算法)

    本题是浙江理工大学ACM入队200题第四套中的A题,同时给出了冒泡排序和选择排序算法 我们先来看一下这题的题面. 由于是比较靠前的题目,这里插一句.各位新ACMer朋友们,请一定要养成仔细耐心看题的习 ...

  8. [HDU 2102] A计划(搜索题,典型dfs or bfs)

    A计划 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submiss ...

  9. 历年NOIP中的搜索题

    什么题目都不会做于是开始做搜索题. 然而我搜索题也不会做了. 铁定没戏的蒟蒻. 1.NOIP2004 虫食算 “对于给定的N进制加法算式,求出N个不同的字母分别代表的数字,使得该加法算式成立.输入数据 ...

随机推荐

  1. Michael Schatz - 序列比对课程

    Michael Schatz - Cold Spring Harbor Laboratory 最近在研究 BWA mem 序列比对算法,直接去看论文,看不懂,论文就3页,太精简了,好多背景知识都不了解 ...

  2. struts 头像上传

    java代码: 1 package cn.itcast.nsfw.user.action; import java.io.File; import java.io.IOException; impor ...

  3. poll()函数的使用

    分类: LINUX poll函数用于监测多个等待事件,若事件未发生,进程睡眠,放弃CPU控制权,若监测的任何一个事件发生,poll将唤醒睡眠的进程,并判断是什么等待事件发生,执行相应的操作.poll函 ...

  4. ExtJS Grid导出excel文件

    ExtJS Grid导出excel文件, 需下载POI:链接:http://pan.baidu.com/s/1i3lkPhF 密码:rqbg 1.将Grid表格数据连同表格列名传到后台 2.后台导出e ...

  5. python——Django(ORM连表操作)

    千呼万唤始出来~~~当当当,终于系统讲了django的ORM操作啦!!!这里记录的是django操作数据库表一对多.多对多的表创建及操作.对于操作,我们只记录连表相关的内容,介绍增加数据和查找数据,因 ...

  6. js 根据不同情况引入不同操作

    1.根据分辨率不同引入不同的JS // 根据不同的分辨率引入不同的JS代码 <script> if (screen.width == 1440 && screen.heig ...

  7. C/C++面试题总结

    腾讯阿里面试题总结:1. 多态机制2. 排序算法(快排.堆排)3. 程序内存分配4. unix多线程5. 哈希查找6. oop特点7. 素数(优化)8. 字符串掩膜操作(内存紧凑)9. 多边形相交10 ...

  8. HTML 表格<table><caption><th><tr><td><thead><tbody><tfoot><col><colgroup>

    <table>标签: 定义和用法: <table>标签定义HTML表格. 简单的HTML表格由table元素以及一个或多个tr.th或td元素组成. tr元素定义表格行,th元 ...

  9. Xcode模拟器不显示SDK版本,反而显示设备ID的解决办法

    今天在应用程序中修改了Xcode app 的名称,结果导致Xcode模拟器不显示SDK版本,反而显示设备ID了,感觉特别的忧伤......如图: 进到Xcode->window->Devi ...

  10. Linux文件的建立、复制、删除和移动命令

    mkdir命令一.mkdir 命令使用权限 所有用户都可以在终端使用 mkdir 命令在拥有权限的文件夹创建文件夹或目录. 二.mkdir 命令使用格式 格式: mkdir [选项] DirName ...