搜索好题记录

已于 2023-04-22 23:09:49 修改
阅读量39 收藏
点赞数
文章标签： 算法 数据结构 c++
于 2023-04-22 23:05:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65154554/article/details/130312229
版权

题目链接：https://www.acwing.com/problem/content/167/

题意：将n只小猫，分成重量不超过m的组别，问最少要分成多少组。

本题用到了：可行性剪枝，最优性剪枝，顺序剪枝

#include<bits/stdc++.h>
using namespace std;
const int N=20;
int n,m,ans=N;
int sum[N],w[N];
void dfs(int k,int u)
{
     if(u>=ans)return;//最优性剪枝
     if(k==n+1)//记得因该搜索到n+1成，这样才是将所有的情况搜索到了
     {
        ans=u;
        return;
     }
     for(int i=1;i<=u;i++)
     {
        if(sum[i]+w[k]<=m)//可行性剪枝
        {
            sum[i]+=w[k];
            dfs(k+1,u);
            sum[i]-=w[k];//记得回溯的时候要恢复到原来的情况
        }
     }
    //新开一辆车
     sum[u+1]=w[k];
     dfs(k+1,u+1);
     sum[u+1]=0;//记得回溯的时候要恢复到原来的情况
}
int main()
{
   cin>>n>>m;
   for(int i=1;i<=n;i++)cin>>w[i];
   sort(w+1,w+1+n);//搜索顺序优化
   reverse(w+1,w+1+n);//搜索顺序优化
   dfs(1,1);
   cout<<ans<<endl;
   return 0;
}

搜索的时候，一定要记得先搜分支较少的分支记搜索顺序优化，也就是要从分支较少的先搜。这题我们可以先将重量大的猫先放，这样就可以尽量将车占满，这样其他的猫就不能放到该车了，这样我们就可以少搜索很多的情况。如果是小猫先放，那么就会有很多猫可以和他一起放到该车，对于和他放到一起的那只猫，就多了一种搜索情况。而且一定要想清楚搜索顺序一定要所有情况都搜索到。

题目链接：https://www.acwing.com/problem/content/168/

题意：填一个9*9的方格数独

用到了 **优化搜索顺序    和   可行性剪枝

#include<bits/stdc++.h>
using namespace std;
const int N=9,M=1<<N;
int ones[M],Map[M];
int row[N],clos[N],cell[3][3];
char s[100];
void draw(int x,int y,int t,bool is_set)
{
  if(is_set)s[x*N+y]='1'+t;
  else s[x*N+y]='.';

  int v=1<<t;
  if(!is_set)v=-v;
  row[x]-=v;
  clos[y]-=v;
  cell[x/3][y/3]-=v;
}
int lowbit(int x)
{
  return x&(-x);
}
int get(int x,int y)
{
  return row[x]&clos[y]&cell[x/3][y/3];
}
int init()
{
  int cnt=0;
  for(int i=0;i<N;i++)
  {
    row[i]=(1<<N)-1;
    clos[i]=(1<<N)-1;
  }
  for(int i=0;i<3;i++)
  {
    for(int j=0;j<3;j++)
    {
      cell[i][j]=(1<<N)-1;
    }
  }
  for(int i=0,k=0;i<N;i++)
  {
    for(int j=0;j<N;j++,k++)
    {
      if(s[k]!='.')
      {
        draw(i,j,s[k]-'1',true);
      }
      else cnt++;
    }
  }
  return cnt;
}
//cnt表示还有多少个方格没填
bool dfs(int cnt)
{
  if(cnt==0)return true;
  int minv=10;
  int x,y;
    //为了将分支最少的点先搜，这样可以节省很多时间
  for(int i=0;i<N;i++)
  {
    for(int j=0;j<N;j++)
    {
      if(s[i*N+j]=='.')
      {
        int state=get(i,j);
        if(ones[state]<minv)
        {
          minv=ones[state];//找到那个可以选择的数最少的空格
          x=i,y=j;
        }
      }
    }
  }
  for(int i=get(x,y);i;i-=lowbit(i))
  {
    int t=Map[lowbit(i)];
    draw(x,y,t,true);
    if(dfs(cnt-1))return true;
    draw(x,y,t,false);
  }
  return false;
}
int main()
{
  for(int i=0;i<N;i++)Map[1<<i]=i;
  for(int i=0;i<M;i++)
  {
    for(int j=i;j;j-=lowbit(j))
    {
      ones[i]+=1;
    }
  }
  while(cin>>s,s[0]!='e')
  {
      int k=init();
       dfs(k);
       puts(s);
  }
  return 0;
}

题目链接：https://www.acwing.com/problem/content/description/169/

题意：让你将一组数分成若干组，是每组的和相同，让你求每组和的最小值

#include<bits/stdc++.h>
using namespace std;
const int N=70;
int w[N],length,sum;
int n;
bool st[N];
bool dfs(int u,int s,int start)
{
     if(u*length==sum)return true;
     if(s==length)return dfs(u+1,0,0);
      //冗余剪枝，我们自己规定了搜索顺序，因为组成木棒的木棍顺序并不影响结果
     for(int i=start;i<n;i++)
     {
         if(st[i])continue;
         //可行性剪枝
         if(s+w[i]>length)continue;
         st[i]=true;
         if(dfs(u,s+w[i],i+1))return true;
         st[i]=false;
         //s=0说明第一根木棒组成失败了，那么我们就不能通过我们有的小木棍组成长度维length的长木棍
         if(s==0)return false;
         //
         if(s+w[i]==length)return false;
         //如果当前位置放长度维w[i]的木棍失败了，那么后面再在该位置放长度和w[i]一样长的木棒也是一样会失败的
         int j=i;
         while(j<n&&w[i]==w[j])j++;
         i=j-1;
     }
     return false;
}
int main()
{
  
  while(cin>>n,n)
  {
    memset(st,0,sizeof(st));
    sum=0;
    for(int i=0;i<n;i++)
    {
      cin>>w[i];
      sum+=w[i];
    }
    //搜索顺序优化，从大到小搜索
    sort(w,w+n);
    reverse(w,w+n);
    length=1;
    while(true)
    {
      if(sum%length==0&&dfs(0,0,0))
      {
        cout<<length<<endl;
        break;
      }
      length++;
    }
  }
  return 0;
}

思路:因为组成木棒的木棍顺序并不影响结果。所以木棒内的木棍，我们可以随便安排顺序，就规定长度大的排在前面吧，这符合我们的搜索顺序优化。因为如果一根小木棒够长，就可以占据更多的长木棒，这样该木棒的组成情况就会少点了，减少了我们搜索的分支了。

相关剪枝证明题解：https://www.acwing.com/solution/content/121003/

题目acwing池塘计数

#include<bits/stdc++.h>
using namespace std;

#define x first
#define y second
typedef pair<int,int>PII;
const int N=1010,M=N*N;
int n,m;
char g[N][N];
PII q[M];
bool st[N][N];  //state状态的缩写，初始都是false
void bfs(int sx,int sy)
{
    int hh=0,tt=0;//hh表示队头，tt表示队尾
    q[0]={sx,sy};//***********
    st[sx][sy]=true;
    while(hh<=tt)
    {
        PII t=q[hh++];//表示从队头将该元素删掉
        for(int i=t.x-1;i<=t.x+1;i++)
        {
            for(int j=t.y;j<=t.y+1;j++)
            {
                if(i==t.x&&j==t.y)continue;//遍历走遍相连的八个格子，可以用两个for循环，将中间那个点去掉即可
                if(i<0||i>=n||j<0||j>=m)continue;//越界的情况
                if(g[i][j]=='.'||st[i][j])continue;

                q[++t]={i,j};
                st[i][j]=true;
            }
        }
    }
}
int main()
{
    //因为输入可能超过100万了，所以用scanf好点
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)scanf("%s",g[i]);//直接用首地址进行读入

    int cnt=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        if(g[i][j]=='W'&&!st[i][j])
        {
            bfs(i,j);//进行填充
            cnt++;
        }
    }  
    printf("%d",cnt);
    return 0;
}

题目：城堡问题

#include<bits/stdc++.h>
using namespace std;

#define x first
#define y second
typedef pair<int,int>PII;
const int N=55,M=N*N;
int n,m;
char g[N][N];
PII q[M];
bool st[N][N];  //state
int dx[4]={0,-1,0,1},dy[4]={-1,0,1,0};

int bfs(int sx,int sy)
{
    int hh=0,tt=0;
    int area=0;

    q[0]={sx,sy};
    st[sx][sy]=true;

    while(hh<=tt)
    {
        PII t=q[hh++];
        area++;

        for(int i=0;i<4;i++)
        {
            int a=t.x+dx[i],b=t.y+dy[i];
            if(a<0||a>=n||b<0||b>=n)continue;
            if(st[a][b])continue;
            if((g[t.x][t.y]>>1)&1)continue;

            q[++tt]={a,b};
            st[a][b]=true;
        }
    }
    return area;
}

int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)cin>>g[i][j];
    }
    int cnt=0,area=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        if(!st[i][j])
        {
            area=max(area,bfs(i,j));
            cnt++;
        }
    }
    cout<<cnt<<endl;
    cout<<area<<endl;
    return 0;
}

题目链接：https://www.dotcpp.com/oj/problem2365.html

#include<bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef pair<int,int>PII;
const int N=1010,M=N*N;
int h[N][N];
int n;
PII q[M];
bool st[N][N];

void bfs(int sx,int sy,bool &has_higher,bool &has_lower)
{
    int hh=0,tt=0;
    q[0]={sx,sy};
    st[sx][sy]=true;

    while(hh<=tt)
    {
        PII t=q[hh++];
        for(int i=t.x-1;i<=t.x+1;i++)
        for(int j=t.y-1;j<=t.y+1;j++)
        {
            if(i<0||i>=n||j<0||j>=n)continue;
            if(h[i][j]!=h[t.x][t.y])
            {
                if(h[i][j]>h[t.x][t.y])has_higher=true;
                else has_lower=true;
            }
            else if(!st[i][j]){
                q[++tt]={i,j};
                st[i][j]=true;
            }
        }
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
    scanf("%d",&h[i][j]);
    int peak=0,valley=0;
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
    {
        if(!st[i][j])
        {
            bool has_higher=false,has_lower=false;
            bfs(i,j,has_higher,has_lower);
            if(!has_higher)peak++;
            if(!has_lower)valley++;
        }
    }
    printf("%d %d\n",peak,valley);
    return 0;
}

题目链接：https://www.dotcpp.com/oj/problem2178.html

#include<bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef pair<int,int>PII;
const int N=1010,M=N*N;
int g[N][N];
int n;
PII q[M];
PII pre[N][N];

int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};

void bfs(int sx,int sy)
{
    int hh=0,tt=0;
    q[0]={sx,sy};

    memset(pre,-1,sizeof(pre));
    pre[sx][sy]={0,0};
    while(hh<=tt)
    {
        PII t=q[hh++];
        for(int i=0;i<4;i++)
        {
            int a=t.x+dx[i],b=t.y+dy[i];
            if(a<0||a>=n||b<0||b>=n)continue;
            if(g[a][b])continue;
            if(pre[a][b].x!=-1)continue;
            q[++tt]={a,b};
            pre[a][b]=t;
        }
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    for(int j=0;j<n;j++)
    {
        scanf("%d",&g[i][j]);
    }
    bfs(n-1,n-1);
    PII END={0,0};
    while(true)
    {
        printf("(%d, %d)\n",END.x,END.y);
        if(END.x==n-1&&END.y==n-1)break;
        END=pre[END.x][END.y];
    }
    return 0;
}

题目链接：https://www.acwing.com/problem/content/190/

#include<bits/stdc++.h>
using namespace std;
const int N=155,M=N*N;
typedef pair<int,int> PII;
PII q[M];
int dis[N][N];
char g[N][N];
int n,m;
int bfs()
{
    int dx[]={-2,-1,1,2,2,1,-1,-2};
    int dy[]={1,2,2,1,-1,-2,-2,-1};

    int sx,sy;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        if(g[i][j]=='K')
        sx=i,sy=j;
    }

    int tt=0,hh=0;
    q[0]={sx,sy};
    memset(dis,-1,sizeof dis);
    dis[sx][sy]=0;

    while(hh<=tt)
    {
        PII t=q[hh++];
        
        for(int i=0;i<8;i++)
        {
            int a=t.first+dx[i] ,b=t.second+dy[i];
            if(a<0||a>=n||b<0||b>=m)continue;
            if(g[a][b]=='*')continue;
            if(dis[a][b]!=-1)continue;
            if(g[a][b]=='H')return dis[t.first][t.second]+1;

            dis[a][b]=dis[t.first][t.second]+1;
            q[++tt]={a,b};
        }
       
    } 
    return -1;
}
int main()
{
    cin>>m>>n;
    for(int i=0;i<n;i++)cin>>g[i];
    cout<<bfs()<<endl;
    return 0;
}

ping yyds
关注
android 实现 搜索保存历史记录功能，android面试基础题
m0_66145114的博客
01-28 1774
//清空本地历史 public void cleanHistory() { SharedPreferences.Editor editor = mSharePreference.edit(); editor.clear(); editor.commit(); updateData(); mSearchHistoryLl.setVisibility(View.GONE); SingleToast.show(this, getString(R.string.clear_history_success), Toa
编程题的记录
01-03
常见的算法如排序（冒泡、选择、插入、快速、归并等）、搜索（线性、二分、深度优先、广度优先等）、动态规划、贪心算法等都是编程题的常客。 最后，文件操作是Python编程中不可或缺的一部分。Python提供了丰富的...
Mybatis常见面试题总结
张维鹏的博客
07-09 59万+
1、什么是Mybatis？ （1）Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。 （2）MyBatis 可以使用XML 或注解来配置和映射原生信息，将POJO映射成数据库中的记录，避免了几乎所...
2023前端面试题整理总结~
LJJONESEED的博客
08-13 3万+
前端面试题
MySQL数据库面试题（2020最新版）
热门推荐
ThinkWon的博客
03-10 121万+
文章目录数据库基础知识为什么要使用数据库什么是SQL？什么是MySQL?数据库三大范式是什么mysql有关权限的表都有哪几个MySQL的binlog有有几种录入格式？分别有什么区别？数据类型mysql有哪些数据类型引擎MySQL存储引擎MyISAM与InnoDB区别MyISAM索引与InnoDB索引的区别？InnoDB引擎的4大特性存储引擎选择索引什么是索引？索引有哪些优缺点？索引使用场景（重点）............
软件/算法类笔试题记录——选择题
xiaotao_1的博客
09-30 1447
总结一下软件类笔试题高频考点。 软件类笔试题一般有选择（单选，多选），填空（不常见），编程（有时只有这一类题）。 对于编程题，可以看剑指offer和刷LeetCode。这里主要记录选择题的考点。 （为了保证文章的简洁性，只列出问题。百度一搜索，就能知道该怎么做） 1，已知树的前序、中序遍历，求它的后序遍历；或者已知树的中序、后序遍历，求它的前序遍历。 2，二分查找，给一个元素，问要查几次（最后那次...
记录一下， 破解某搜题软件
build_csdn的博客
06-20 1659
去年这个时候一大堆网课，找了一大批搜题的软件最后发现学小易不错后来想着拿到api 不就方便了吗，那时候简单的fiddler 代理就可以捕获到，而且还是明文的报文，反手用opencv 做了一个答题卡式的扫描程序，现在又到用的时候发现版本太低，随后走老路： fiddler wifi代理 抓app 显示 网络异常，检测到网络中存在代理。不得不说做的是真绝，只要检测到系统带来就直接退出，之后转到ios 系统试着找一下有没有有用的报文。还是一样。用vpn httpcanary一样没用。所以基本上这两个方法现在的app
2024年前端面试题汇总
sun_qqq的博客
02-08 8万+
最近面试被打击的体无完肤，于是把面试题记录下来分享一下。vue真是必问框架，八股文该背的还是得背！
大数据面试题记录
豆子的collection
08-25 9269
1 海量日志数据，提取出某日访问百度次数最多的那个IP
大数据面试130题
大数据研习社
03-11 4028
大数据面试题总结一波，助力准备在年底跳槽寻找好工作的小伙伴们，只有度过笔试这一关才能在下面的关卡中大展宏图！Hadoop，Spark，Flink，数据仓库，10多个技术面、100多道面试题，为你的面试保驾护航。
MySQL 面试题
木村的博客
09-02 6万+
MySQL 面试题 MySQL 涉及的内容非常非常非常多，所以面试题也容易写的杂乱。当年，我们记着几个一定要掌握的重心： 重点的题目添加了【重点】前缀。 索引。 锁。 事务和隔离级别。 因为 MySQL 还会有部分内容和运维相关度比较高，所以本文我们分成两部分【开发】【运维】两部分。 对于【开发】部分，我们需要掌握。 对于【运维】部分，更多考验开发的知识储备情况，当然能回答出来是比较好的...
LeetCode:LeetCode做题记录
03-09
"LeetCode做题记录"很可能是某位用户在刷题过程中的个人笔记或总结，可能包括解题思路、代码实现、错误分析和学习心得等内容。 通过熟做LeetCode的500道题目，即使是编程基础相对较弱的“差生”，也有机会大幅提高...
leetcode题库-leetcode:我的leetcode做题记录
06-29
此仓库是我的LeetCode做题记录，代码使用Java实现。作为刚开始做LeetCode的新人，目前为止解决了55题（2020-11-07），突发奇想想要通过记录到github来监督自己做题，并且方便日后对所做过的题的复盘，计划把以前做过...
leetcode题库-LeetCode:刷题记录
06-29
introduction_to_data_structure_binary_search_tree包为二叉搜索树专题记录。 n_ary_tree包为N叉树专题记录。 trie包为前缀树专题记录。 算法 binary_search包为二分查找专题记录。 array_and_string包为数组和字符...
全国大学生数学建模竞赛B题记录.zip
10-23
题目"全国大学生数学建模竞赛B题记录.zip"很可能包含2018年赛事B题的相关资料，包括参赛队伍的研究成果、解题思路、模型构建、数据处理等内容。文件"CUMCM2018-master"可能是此次竞赛的一个项目仓库，可能包含了源...
【C++算法】8.双指针_四数之和
hlyd520的博客
10-04 603
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 409
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 129
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 825
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
数据结构与算法选择题详解
15. **VSAM文件**：第15题提到了VSAM文件的记录存储方式，但未给出完整信息。 填空题涉及了算法时间复杂度、链表操作、栈操作、字符串长度、矩阵存储、二叉链表、选择排序、查找的平均查找长度、循环队列判断空的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值