深搜-4

最新推荐文章于 2024-03-31 20:38:31 发布
最新推荐文章于 2024-03-31 20:38:31 发布
阅读量399 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hzy_hzy_hzy/article/details/68482847
版权 
1.传数组问题，指向的是同一空间。递归传数组时，在这一层开个临时数组然后传，下一层就能访问这个临时数组了。定义一个数组，然后传，不开临时数组，，相当于没传。
2.递归终止条件控制问题。
3.回溯问题。
#include<bits/stdc++.h>
using namespace std;
const int N=1e3;
struct node
{
    int x,y;
}a[100],b[100];
int n,m,k;
int vis[100],vis1[100];
double ans;
double dis(node p,node q)
{
    return sqrt((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y));
}
void dfs(int pos,int num)
{
    if(pos>m) return;
    if(num==k)
    {
        double s=0;
        for(int i=0;i<n;i++)
        {
            double minn=999999;
            for(int j=0;j<m;j++)
            {
                if(vis[j]&&dis(a[i],b[j])<minn)
                {
                    minn=dis(a[i],b[j]);
                }
            }
            s+=minn;
        }
//        for(int i=0;i<m;i++)
//        {
//            if(vis[i]) printf("%d ",i);
//        }cout<<endl;printf("minn=%lf\n",s);

        if(s<ans)
        {
            ans=s;
            for(int i=0;i<m;i++)
            {
                vis1[i]=vis[i];
            }
        }
        //printf("s=%lf num=%d\n",s,num);
        return ;
    }
        vis[pos]=1;dfs(pos+1,num+1);
        vis[pos]=0;dfs(pos+1,num);
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&b[i].x,&b[i].y);
        }
        ans=999999999;
        dfs(0,0);
        //printf("%lf\n",ans);
        for(int i=0;i<m;i++)
        {
            if(vis1[i]) printf("%d ",i+1);
        }
    }
    return 0;
}//第一遍手打暴力来遍-50

#include<bits/stdc++.h>//终止条件控制问题
#define inf 999999
using namespace std;
const int N=1e3;
struct node
{
    int x,y;
}a[100],b[100];
int n,m,k;
int vis[100],vis1[100];
double diss[100][100],c[100];
double ans;
double dis(node p,node q)
{
    return sqrt((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y));
}
void dfs(int pos,int num,double s,double *t)
{
    //if(pos>m) return;/*放上面（第pos个位置填到m-1，m就不能填了，但下面的判断num==k需要到m步才会处理）一直没想到原因，，丫丫*/
    if(num>k) return;
    if(num==k)
    {   //printf("%lf %d ",s,pos);
        //for(int i=0;i<m;i++) if(vis[i]) printf("%d ",i);printf("s=%lf\n",s);
        //for(int i=0;i<n;i++) printf("%lf ",t[i]);cout<<endl;
        if(s<ans)
        {
            ans=s;
            for(int i=0;i<m;i++)
            {
                vis1[i]=vis[i];//printf("%d ",vis[i]);
            }//cout<<endl;
        }
        return ;
    }
    if(pos>=m) return;/*放下面，分析清楚了原因，就知道如何控制了，，下次就不乱放，找种做模板思维*/


        vis[pos]=1;
        double pp[55],ss=s;
        //cout<<"pos="<<pos<<" ";for(int i=0;i<n;i++) printf("%lf ",t[i]);cout<<endl;
        for(int i=0;i<n;i++)
        {
            pp[i]=t[i];
            if(diss[i][pos]<pp[i])
            {
                ss=ss-pp[i]+diss[i][pos];
                pp[i]=diss[i][pos];
            }
            //ss+=pp[i];
        }//printf("ss=%lf\n",ss);
        //for(int i=0;i<n;i++) printf("%lf ",pp[i]);cout<<endl;
        dfs(pos+1,num+1,ss,pp);
        vis[pos]=0;dfs(pos+1,num,s,t);
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&b[i].x,&b[i].y);
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
               diss[i][j]=dis(a[i],b[j]);//printf("%lf ",diss[i][j]);
            }//cout<<endl;
        }
        for(int i=0;i<n;i++) c[i]=inf;
        ans=999999999;
        dfs(0,0,inf*n,c);
        //printf("%lf\n",ans);
        for(int i=0;i<m;i++)
        {
            if(vis1[i]) printf("%d ",i+1);
        }
    }
    return 0;
}//-80/*感觉是换了方法，改用传数组写*/
#include<bits/stdc++.h>//加判断
#define inf 999999
using namespace std;
const int N=1e3;
struct node
{
    int x,y;
}a[100],b[100];
int n,m,k;
int vis[100],vis1[100];
double diss[100][100],c[100];
double ans;
double dis(node p,node q)
{
    return sqrt((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y));
}
void dfs(int pos,int num,double s,double *t)
{
    if(k-num>m-pos) return;/*看后面的数量够不够*/
    if(num==k)
    {
        if(s<ans)
        {
            ans=s;
            for(int i=0;i<m;i++)
            {
                vis1[i]=vis[i];
            }
        }
        return ;
    }
       //if(pos>=m) return;
        double pp[55],ss=s;
        //cout<<"pos="<<pos<<" ";for(int i=0;i<n;i++) printf("%lf ",t[i]);cout<<endl;
        int flag=0;
        for(int i=0;i<n;i++)
        {
            pp[i]=t[i];
            if(diss[i][pos]<pp[i])
            {
                flag=1;
                ss=ss-pp[i]+diss[i][pos];
                pp[i]=diss[i][pos];
            }
        }
        //for(int i=0;i<n;i++) printf("%lf ",pp[i]);cout<<endl;
        if(flag) {vis[pos]=1;dfs(pos+1,num+1,ss,pp);} /*加了判断是否选这个邮局*/
        vis[pos]=0;dfs(pos+1,num,s,t);
}
int main()
{
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&b[i].x,&b[i].y);
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
               diss[i][j]=dis(a[i],b[j]);//printf("%lf ",diss[i][j]);
            }//cout<<endl;
        }
        for(int i=0;i<n;i++) c[i]=inf;
        ans=999999999;
        dfs(0,0,inf*n,c);
        for(int i=0;i<m;i++)
        {
            if(vis1[i]) printf("%d ",i+1);
        }
    }
    return 0;
}-90/*加了些判断，但最后点超时，丫丫*/

#include<bits/stdc++.h>//问题点。。//感觉传数组耗时间更多了，，每次都要传n大小的数组。。找到方案后再n*m记录结果肯定超时，C10/25*n*m超。
using namespace std;
const int N=1e3;
typedef long long ll;
struct node
{
    int x,y;
}a[100],b[100];
int n,m,k;
int vis[100],vis1[100];
double ans;
double dis(node p,node q)
{
    return sqrt((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y));
}
void dfs(int pos,int num)
{
    if(pos>m) return;
    if(num==k)
    {
        double s=0;
        for(int i=0;i<n;i++)
        {
            double minn=999999;
            for(int j=0;j<m;j++)
            {
                if(vis[j]&&dis(a[i],b[j])<minn)
                {
                    minn=dis(a[i],b[j]);
                }
            }
            s+=minn;
        }
        if(s<ans)
        {
            ans=s;
            for(int i=0;i<m;i++)
            {
                vis1[i]=vis[i];
            }
        }
        //printf("s=%lf num=%d\n",s,num);
        return ;
    }
        vis[pos]=1;dfs(pos+1,num+1);
        vis[pos]=0;dfs(pos+1,num);
}
int main()
{
    //ll s=1;
    //for(int i=1;i<=25;i++) s*=2;cout<<s<<endl;
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&b[i].x,&b[i].y);
        }
        ans=999999999;
        int book[100];
        memset(book,0,sizeof(book));
        for(int i=0;i<n;i++)
        {
            double minn=99999;int l=0;
            for(int j=0;j<m;j++)
            {
                if(dis(a[i],b[j])<minn)
                {
                    minn=dis(a[i],b[j]);
                    l=j;
                }
            }
            book[l]=1;
        }
        int num=0;
        for(int i=0;i<m;i++)
        {
            if(book[i]){b[num].x=b[i].x,b[num++].y=b[i].y;}
        } m=num;
        dfs(0,0);
        for(int i=0;i<m;i++)
        {
            if(vis1[i]) printf("%d ",i+1);
        }
    }
    return 0;
}/*有问题的贪心*/

#include<bits/stdc++.h>//回溯错误 偶然换位置发现的错误
#define inf 999999
using namespace std;
const int N=1e3;
struct node
{
    int x,y;
}a[100],b[100];
int n,m,k;
int vis[30],vis1[30];
double diss[100][100],c[100];
double ans;
double dis(node p,node q)
{
    return sqrt((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y));
}
void dfs(int pos,int num,double s,double *t)
{
    if(pos>m||k-num>m-pos) return;/**/
    if(num==k)
    {
        if(s<ans)
        {
            ans=s;
          //  for(int i=0;i<m;i++)
            {
                //vis1[i]=vis[i];
                memcpy(vis1,vis,sizeof(vis));
            }
        }
        return ;
    }
       //if(pos>=m) return;
        double pp[55],ss=s;
        //cout<<"pos="<<pos<<" ";for(int i=0;i<n;i++) printf("%lf ",t[i]);cout<<endl;
        int flag=0;
        for(int i=0;i<n;i++)
        {
            pp[i]=t[i];
            if(diss[i][pos]<pp[i])
            {
                flag=1;
                ss=ss-pp[i]+diss[i][pos];
                pp[i]=diss[i][pos];
            }
        }
        //for(int i=0;i<n;i++) printf("%lf ",pp[i]);cout<<endl;
        /*vis[pos]=0;dfs(pos+1,num,s,t);
        if(flag) {vis[pos]=1;dfs(pos+1,num+1,ss,pp);vis[pos]=0;}*/  //--回溯的体现。后面的回溯竟忘了，变-40，深搜思想不深刻呀。后来改用这种，神奇错了，改过。
        /*if(flag){vis[pos]=1;dfs(pos+1,num+1,ss,pp);}vis[pos]=0;dfs(pos+1,num,s,t);*/ //这样写开始理解为选标记为1，不选标记为0；是那么一回事，同时vis[pos]=0,也是回溯。开始写的这种。
}                                                                                 
int main()
{
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&b[i].x,&b[i].y);
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
               diss[i][j]=dis(a[i],b[j]);//printf("%lf ",diss[i][j]);
            }//cout<<endl;
        }
        for(int i=0;i<n;i++) c[i]=inf;
        ans=999999999;
        dfs(0,0,inf*n,c);
        for(int i=0;i<m;i++)
        {
            if(vis1[i]) printf("%d ",i+1);
        }
    }
    return 0;
}
邮局
Hzy_hzy_hzy
关注
专栏目录
深搜（深度优先搜索DFS）
qq_43657344的博客
04-06 2545
深搜（深度优先搜索） 深度优先搜索属于图算法的一种，英文缩写为DFS，其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。 一、从枚举到深搜 在我们遇到的一些问题当中，有些问题我们不能够确切的找出数学模型，即找不出一种直接求解的方法，解决这一类问题，我们一般采用搜索的方法解决。搜索就是用问题的所有可能去试探，按照一定的顺序、规则，不断去试探，直到找到问题的解，试完...
深搜---P1596水坑问题(C语言)
qq_62612545的博客
01-12 757
附上题目:P1596水坑 题目 由于近期的降雨，雨水汇集在农民约翰的田地不同的地方。我们用一个NxM(1<=N<=100;1<=M<=100)网格图表示。每个网格中有水('W') 或是旱地('.')。一个网格与其周围的八个网格相连，而一组相连的网格视为一个水坑。约翰想弄清楚他的田地已经形成了多少水坑。给出约翰田地的示意图，确定当中有多少水坑。 [1]输入格式: 第1行：两个空格隔开的整数：N 和 M 第2行到第N+1行：每行M个字符，每个字符是'W'或'.'，它们表示网格图中
深搜
dezhi4674的博客
06-04 83
深搜 搜索与回溯是计算机解题中常用的算法，很多问题无法根据某种确定的计算法则来求解，可以利用搜索与回溯的技术求解。回溯是搜索算法中的一种控制策略。它的基本思想是：为了求得问题的解，先选择某一种可能情况向前探索，在探索过程中，一旦发现原来的选择是错误的，就退回一步重新选择，继续向前探索，如此反复进行，直至得到解或证明无解。 如迷宫问题：进入迷宫后，先随意选择一个前进方向，一步步向前试探...
【POJ1330】最近公共祖先（LCA）：并查集+深搜 - cxllyg的专栏 - 博客频道 - CSDN.NET1
08-03
如果我们寻找节点3和8的LCA，我们可以记录找到3和8的路径，分别为3-4-6-10和8-6-10。然后我们比较两个路径，从相同的起点（这里是6）开始，发现6是第一个相同的节点，因此6就是LCA。 以下是一个C++函数示例，用于在...
dfs深搜--洛谷P1706 全排列问题
weixin_47208643的博客
07-25 249
题目描述 输出自然数 111 到 nnn 所有不重复的排列，即 nnn 的全排列，要求所产生的任一数字序列中不允许出现重复的数字。 输入格式 一个整数 nnn。 输出格式 由 1∼n1 \sim n1∼n 组成的所有不重复的数字序列，每行一个序列。 每个数字保留 555 个场宽。 输入输出样例 输入 #1 3 输出 #1 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 说明/提示 1≤n≤91 \leq n \
dfs深搜--八皇后问题
weixin_47208643的博客
07-25 178
题目描述 一个如下的 6×66 \times 66×6 的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线（包括两条主对角线的所有平行线）上至多有一个棋子。 上面的布局可以用序列 2 4 6 1 3 52\ 4\ 6\ 1\ 3\ 52 4 6 1 3 5 来描述，第 iii 个数字表示在第 iii 行的相应位置有一个棋子，如下： 行号 1 2 3 4 5 61\ 2\ 3\ 4\ 5\ 61 2 3 4 5 6 列号 2 4 6 1 3 52\ 4\ 6\ 1\ 3\ 52 4
【YbtOJ高效进阶 深搜-1】拔河比赛
blog
01-09 431
现在有n个点，每个点有个值，现在要将这堆点分成两份，其中这两份的点的数量之差不能超过1，求使这两堆点的值的和之差最小
深搜（DFS）
Huberyxiao的博客
03-21 8608
深度优先搜索——不撞南墙不回头 深搜是作为一种遍历或搜索图和树的算法。 思想：不撞南墙不回头！ 首先选取一个未访问的点作为源节点。从源节点选取一条路一直往下走，沿着当前顶点的边，访问这条路线，直到走不下去为止。这时返回上一顶点，继续试探访问此顶点的其余子顶点，直到当前顶点的子顶点都被访问过，那么，返回上一顶点，继续重复。从而实现遍历。 来个简单的例子模拟DFS的过程： （首先，我们默认优先选择...
深搜(dfs算法)
qq_44996964的博客
08-10 584
有一个长方形的房间，覆盖了正方形的磁砖。每块磁砖的颜色，要么是红色，要么是黑色。一名男子站在一块黑色的磁砖上。他可以从一块磁砖移至相邻四块磁砖中的某一块。但是，他不允许在红色磁砖上移动，他只允许在黑色磁砖上移动。 编写一个程序，使得他允许重复上述的移动，判断他所能到达的黑色磁砖的数量。 输入 输入由多个数据集组成。数据集的起始行包含了两个正整数 W 和 H；W 和 H 分别是 x- 和 y- 方向...
深搜(看这一篇就够了)
Lucas55555555的博客
03-31 1766
深搜是一种对数串或图形进行遍历的算法。它会从起点像树状图一样向下进行探索，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。回溯是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。深度优先搜索是对图进行搜索的算法，目的也都是从起点开始搜 索直到到达指定顶点（终点）。
Python深搜讲解
最新发布
06-13
Python中的深度优先搜索（Depth-First Search，DFS）是一种用于遍历或搜索树或图数据结构的算法策略。在深度优先搜索中，我们从起始节点开始，尽可能深地沿着分支探索，直到到达某个叶子节点（没有未访问的孩子节点），然后回溯到上一个节点并继续下一个分支，直到所有可达节点都被访问过。 以下是深度优先搜索的基本步骤： 1. **选择一个起始节点**：通常是从根节点开始，如果没有根节点，则选择任意一个未访问的节点。 2. **标记当前节点为已访问**：将其添加到已访问集合中，避免重复访问。 3. **递归遍历子节点**：对于当前节点的所有未访问子节点，递归调用DFS函数。 4. **如果找到目标节点**：返回结果。 5. **如果当前节点无子节点或所有子节点都已访问**：结束当前路径，回溯到上一个节点。 深度优先搜索可以用递归实现（如`stack`数据结构），也可以使用堆栈辅助（模拟递归过程）。常见的应用包括迷宫问题、拓扑排序、遍历文件系统等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值