陕西省集训day3（搜索上）

最新推荐文章于 2023-09-30 12:39:13 发布

zjy2015302395

最新推荐文章于 2023-09-30 12:39:13 发布

阅读量447

点赞数

分类专栏： acm 基本算法陕西集训

本文链接：https://blog.csdn.net/zjy2015302395/article/details/52287462

版权

acm 同时被 3 个专栏收录

178 篇文章 0 订阅

订阅专栏

基本算法

166 篇文章 0 订阅

订阅专栏

陕西集训

9 篇文章 0 订阅

订阅专栏

3#A题：
http://acm.split.hdu.edu.cn/showproblem.php?pid=1175

题意：

简单版练练看，不能在外侧连，而且折线不能超过两次，中间当然也不能碰到别的东西，简化到每次只问一对，两次没有关系。

思路：

搜索的时候记得加上上一次的方向，加一个参数就行，如果变了方向就+1，不能超过2。。。

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
int x1,y2,x2,y1;
int n,m;
int a[1010][1010];
bool vis[1010][1010];
int dir[4][2] = { {0,1},{0,-1},{1,0},{-1,0} };
int book[4] = {2,3,4,5};
int flag;
void dfs(int sp1,int sp2,int turn,int di)
{
   // cout <<"  "<< sp1<<"  "<<sp2 <<"  " <<turn<<endl;
    if(flag)
            return;
    if(turn == 3)
            return ;
    if(sp1 == x2&&sp2 == y2)
       {
            flag = 1;
            return ;
       }
//cout << sp1<<"  "<<sp2 <<"  " <<turn<<endl;
    for(int i = 0 ; i < 4; i++)
    {
        int nowx = sp1+dir[i][0];
        int nowy = sp2+dir[i][1];

        if(nowx>0&&nowx<=n&&nowy>0 &&nowy<=m&&a[nowx][nowy] == 0&&!vis[nowx][nowy])
        {
            vis[nowx][nowy] = 1;
            if(di != book[i])
                dfs(nowx,nowy,turn+1,book[i]);
            else
                dfs(nowx,nowy,turn,book[i]);
            vis[nowx][nowy] = 0;
        }
        else if(nowx == x2&&nowy == y2 )
            flag =1;
    }
    return;
}

int main()
{
    while(   cin >>n>>m)
    {
        if(n == 0 && m ==0)
            break;
        for(int i = 1 ; i <= n ; i++)
            for(int j = 1 ; j <= m ; j++)
                scanf("%d",&a[i][j]);
        int q;
        cin >> q;
        while(q--)
        {
            flag =0;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            memset(vis,0,sizeof(vis));
            if(x1 == x2 && y1 == y2 && a[x1][y1]!=0)//如果是同一左边，则否定
            printf("NO\n");
          else if(a[x1][y1] == a[x2][y2] && a[x1][y1])//不同坐标，值相同且不为0              {

            {
                dfs(x1,y1,-1,0);
                if(flag)
                    cout <<"YES"<<endl;
                else
                    cout << "NO" <<endl;
            }
            else
                cout <<"NO"<<endl;
        }
    }
    return 0;
}

B题：

http://acm.split.hdu.edu.cn/showproblem.php?pid=2510

题意：

上一行的正上方和右上方是一样的就是+，不一样的就是-，要求+和-的个数一样，求符合条件的个数

思路：

第一行确定的话，后面的自然就是确定的，（n < 24 ?)
怎么能不打表QAQ

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int MAXN = 25;

int ans[MAXN], n;
int A[MAXN][MAXN], sum[2];

void Search(int x){
    if (x > 1 && sum[0] == sum[1]) ans[x-1] ++;
    if (x == 24+1) return;
    for (int i = 0 ; i <= 1 ; i ++){
        sum[i] ++;
        A[1][x] = i;
        for (int j = 1; j < x ; j ++) {
            A[j+1][x-j] = (A[j][x-j] == A[j][x-j+1] ? 1 : 0);
            sum[A[j+1][x-j]] ++;
        }
        Search(x+1);
        sum[i] --;
        A[1][x] = i;
        for (int j = 1; j < x ; j ++) {
            A[j+1][x-j] = (A[j][x-j] == A[j][x-j+1] ? 1 : 0);
            sum[A[j+1][x-j]] --;
        }
    }
}

const int List[24] = {0,0,4,6,0,0,12,40,0,0,171,410,0,0,1896,5160,0,0,32757,59984,0,0,431095,822229};

int main(){
    //for (int i = 1; i <= 24; i ++) ans[i] = 0;
    //sum[0] = sum[1] = 0;
    //Search(1);
    //for (int i = 1 ; i <= 24 ; i ++) cout <<ans[i] <<"," ;

    while ( cin >> n && n != 0 ) cout <<n << " " << List[n-1] <<"\n";
}

C题：

题意：

加一些+和一个=使得等式成立

思路：

+的位置有好多种，想到搜索，再在每次分完之后循环一遍前缀和，看有没有所有数的和的一半，如果有等号放在那就成立了
每两个数字之间可以选择断或者不断，那么就是2^n，但是n只有15，没什么问题

#include <iostream>
#include <cstdio>
#include <cstring>
char s[100010];
bool flag[100010];
int len;
int an[100010];
int anscnt = 0;
using namespace std;

void dfs(int step)
{
    if(step == len-1)
    {
        int cnt = 0,ans = 0;
        for(int i = 0 ; i < len ;i++)
        {
            if(flag[i] == true)
            {
                ans = ans*10+s[i]-'0';
                an[cnt++] = ans;
                ans = 0;
            }
            else
                ans = ans*10+s[i]-'0';
        }
        if(ans != 0)
            an[cnt++] = ans;
        int sum = 0,left = 0;
        for(int i = 0 ; i  < cnt ;i++)
                    sum += an[i];

        for(int i = 0 ; i < cnt ;i++)
        {
            left += an[i];
            if(left == sum-left)
                anscnt++;
        }
        return;
    }
    flag[step] = 1;
    dfs(step+1);
    flag[step] = 0;
    dfs(step+1);
}

int main()
{
   while(scanf("%s",s))
   {
       if(s[0] == 'E')
        break;
       else
        {
            memset(flag,false,sizeof(flag));
            memset(an,0,sizeof(an));
            len =strlen(s);
            anscnt = 0;
            dfs(0);
            cout << anscnt <<endl;
        }
   }
    return 0;
}

D题：

http://acm.split.hdu.edu.cn/showproblem.php?pid=1455

题意：

一些棍子，几个一组，使得每组拼起来长度相同，问最小的这个长度和是多少
##思路：
经典搜索小木棍，剪枝蛮多的，先大到小排序，如果大的在当前为第一个的时候都不行，那么这个方案就没有dfs下去的必要了，因为就算小的棍子满足了后面还是没法处理长的，这题我觉得可以二分那个长度，但是长度可定是总长度的约数，扫一遍也没什么，还有很重要的一刀就是如果后面的木棍和当前的一样长，且当前的这跟不能拼出当前长度，那也他相同的肯定都不行，不知道为什么非要卡这一刀。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int Max = 65;

int n, len, stick[Max];
bool flag, vis[Max];

bool cmp(int a, int b)
{
    return a > b;
}

void dfs(int dep, int now_len, int u)  
{
    if(flag) return;
    if(now_len == 0)                       {
        int k = 0;
        while(vis[k]) k ++;              
        vis[k] = true;
        dfs(dep + 1, stick[k], k + 1);
        vis[k] = false;
        return;
    }
    if(now_len == len)               
    {
        if(dep == n) flag = true;        
        else dfs(dep, 0, 0);
        return;
    }
    for(int i = u; i < n; i ++)
        if(!vis[i] && now_len  + stick[i] <= len)
        {
            if(!vis[i-1] && stick[i] == stick[i-1]) continue;    
            vis[i] = true;
            dfs(dep + 1, now_len + stick[i], i + 1);
            vis[i] = false;
        }
}

int main()
{
    while(scanf("%d", &n) && n != 0)
    {
        int sum = 0;
        flag = false;
        for(int i = 0; i < n; i ++)
        {
            scanf("%d", &stick[i]);
            sum += stick[i];
        }
        sort(stick, stick + n, cmp);     
        for(len = stick[0]; len < sum; len ++)
            if(sum % len == 0)          
            {
                memset(vis, 0, sizeof(vis));
                dfs(0, 0, 0);
                if(flag) break;
            }
        printf("%d\n", len);
    }
    return 0;
}

E题：

http://acm.split.hdu.edu.cn/showproblem.php?pid=1043

题意：

八数码问题，如何移动空格变成顺序牌

思路：

正解应该是IDA*，但是双向bfs是可以水一下的，IDA*有时间会补一发

#include <iostream>
#include <unordered_set>
#include <unordered_map>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;

const int dx[4] = {1,-1,0,0};
const int dy[4] = {0,0,-1,1};
const char sign[4] = {'d','u','l','r'};

int source, target;
int tmp[4][4], Que[1000000] ;

unordered_set<int> vis;
unordered_map<int,int> Next;

int Move(int s ,int k){
    int s0 = s, xx , xy ;
    for (int i = 3 ; i >= 1; i --){
        for (int j = 3 ; j >= 1 ; j --){
            int dig = s0 % 10;
            s0 /= 10;
            if (dig == 0) {
                xx = i , xy = j;
            }
            tmp[i][j] = dig;
        }
    }
    if ( xx + dx[k] <= 0 || xx + dx[k] > 3 || xy + dy[k] <= 0 || xy + dy[k] > 3 ) {
        return -1;
    }
    swap(tmp[xx][xy] , tmp[xx+dx[k]][xy+dy[k]]);
    int t = 0;
    for ( int i = 1 ; i <= 3 ; i ++) for ( int j = 1 ; j <= 3 ; j  ++ ) t = t * 10 + tmp[i][j];
    return t;
}

void Out(int t) {
    if (t == target) return ;
    else {
        int s = Next[t] ; // t -> s
        for ( int i = 0 ; i < 4 ; i ++ ) if ( Move(t , i) == s ) {
            cout << sign[i];
            Out(s) ;
        }
    }
}

void Bfs() {
    int L = 1 , R = 1 ; Que[1] = target;
    vis.clear() ;
    vis.insert(target);
    while ( L <= R ) {
        int s = Que[L] ; L ++ ;
        for ( int k = 0 ; k < 4 ; k ++ ) {
            int t = Move(s , k);
            if ( t == -1 ) continue ;
            if ( vis.find(t) != vis.end() ) ;
            else {
                vis.insert(t);
                Next[t] = s ;
                Que[++R] = t;
            }
        }
    }
}

int main()
{
    target = 0;
    for (int i = 1; i <= 8 ; i ++) target = target * 10 + i;
    target *= 10;
    Bfs();

    string s ; int x;
    while ( cin >> s ) {
        source = 0;
        for (int i = 0 ; i < 9 ; i ++) {
            if ( i > 0 ) cin >> s ;
            if (s == "x") x = 0;
            else x = (s[0] - '0');
            source = source * 10 + x;
        }
        if (vis.find(source) == vis.end()) cout << "unsolvable\n";
        else {
            Out(source);
            cout << "\n";
        }
    }

    return 0;
}