3月23日星期四

一、刷题题解

1、简单搜索&&进阶搜索 - Virtual Judge (vjudge.net)

（1、）这题是说有n个题目，每个题在做完不同题后，需要后面做的题比当前做的题难度要大（时间更久），找出这样的做题顺序做出最多的题，总是从的一题开始花费0分钟；

（2、）那么我们就可以用DFS，通过上一题的状态按照条件搜索下一题，继续搜索直到搜索完；

（3、）注意更新最大题数，以及回溯；

附代码

#include <iostream>
#include <memory.h>
using namespace std;

int n, js;
int gx[20][20];
int vis[20];

void dfs(int dq, int i, int max)
{
    if (dq >js)
     {
        js = dq;
    }
    vis[i] = 1;
    for (int j = 0; j < n; j++)
    {
        if (vis[j]==0&&gx[i][j] >= max)
        {
            dfs(dq + 1, j, gx[i][j]);
        }
    }
    vis[i] = 0;
} 

int main() {
    while (cin >> n)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                cin >> gx[i][j];
            }
        }
        dfs(1, 0, 0);
        cout << js << endl;
        memset(vis,0,sizeof(vis));
        js=0;
    }
    return 0;
}

2、简单搜索&&进阶搜索 - Virtual Judge (vjudge.net)

（1、）这题是说给你个密码锁4位数的初始状态a，然后通过对它4数上的任意一个数执行+1，-1，相邻两个交换的操作，变成另外一个状态b输出最小操作数；

（2、）那么我们就可以通过BFS+队列+剪枝（标记），把当前状态能衍生出来的状态入队，并记录步数，然后通过得到的新状态和b比较相等即可输出当前步数；

附代码

#include<iostream>
#include<queue>
#include<stdio.h>
using namespace std;
 
struct node
{
   int num[4];
   int step;
}s1,s2;

 void BFS()
 { 
     queue<struct node> qe;
     int jl[10][10][10][10]={0};
     struct node t;
     
     qe.push(s1);
     
     jl[s1.num[0]][s1.num[1]][s1.num[2]][s1.num[3]]=1;
     
     while(!qe.empty())
     {
        t=qe.front();
        qe.pop();
        if(t.num[0]==s2.num[0]&&t.num[1]==s2.num[1]&&t.num[2]==s2.num[2]&&t.num[3]==s2.num[3])
        {  
             cout<<t.step<<endl;
             return ;
         }
         for(int i=0;i<4;i++)
        {   
            node next=t;
             next.num[i]++;
             if(next.num[i]==10) next.num[i]=1;
             
            if(!jl[next.num[0]][next.num[1]][next.num[2]][next.num[3]])
             {
                 jl[next.num[0]][next.num[1]][next.num[2]][next.num[3]]=1;
                next.step++;
                 qe.push(next);
            }
         }
         for(int i=0;i<4;i++)
         { 
             node next=t;
             next.num[i]--;
             if(next.num[i]==0) next.num[i]=9;
            
            if(!jl[next.num[0]][next.num[1]][next.num[2]][next.num[3]])
            {
                jl[next.num[0]][next.num[1]][next.num[2]][next.num[3]]=1;
                 next.step++;
                 qe.push(next);
             }
         }
         for(int i=0;i<3;i++)
         {  
             node next=t;
             swap(next.num[i],next.num[i+1]);
            
            if(!jl[next.num[0]][next.num[1]][next.num[2]][next.num[3]])
             {
                 jl[next.num[0]][next.num[1]][next.num[2]][next.num[3]]=1;
                 next.step++;
                 qe.push(next);
             }
         }    
    }
 }
 
int main()
{    int n;
     cin>>n;
     getchar();
     while(n--)
     {char c1[5];
      char c2[5];
      cin>>c1>>c2;
      for(int i=0;i<4;i++)
      {
        s1.num[i]=c1[i]-'0';
        s2.num[i]=c2[i]-'0';
      }
      BFS();
    }
     return 0;
 }