2971:抓住那头牛

总时间限制:
2000ms
内存限制:
65536kB
描述

农夫知道一头牛的位置,想要抓住它。农夫和牛都位于数轴上,农夫起始位于点N(0<=N<=100000),牛位于点K(0<=K<=100000)。农夫有两种移动方式:

1、从X移动到X-1或X+1,每次移动花费一分钟

2、从X移动到2*X,每次移动花费一分钟

假设牛没有意识到农夫的行动,站在原地不动。农夫最少要花多少时间才能抓住牛?

输入
两个整数,N和K
输出
一个整数,农夫抓到牛所要花费的最小分钟数
样例输入
5 17
样例输出
4深搜 炸:
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;
const int N=100010;

bool vis[N];
int people;
int milk;
int answer=99999999;
int nowans=0;

inline int read()
{
    int x=0;char c=getchar();
    while(c<‘0‘||c>‘9‘)c=getchar();
    while(c>=‘0‘&&c<=‘9‘)x=x*10+c-‘0‘,c=getchar();
    return x;
}

void dfs(int nowpeople)
{
    vis[nowpeople]=1;
    if(nowpeople==milk)
    {
        answer=min(answer,nowans);
        return ;
    }
    if(!vis[nowpeople+1]&&nowpeople+1>0&&nowpeople+1<=milk+1)
    {
        nowans++;
        vis[nowpeople+1]=1;
        dfs(nowpeople+1);
        nowans--;
        vis[nowpeople+1]=0;
    }
    if(!vis[nowpeople-1]&&nowpeople-1>0&&nowpeople-1<=milk+1)
    {
        nowans++;
        vis[nowpeople-1]=1;
        dfs(nowpeople-1);
        nowans--;
        vis[nowpeople-1]=0;
    }
    if(!vis[nowpeople*2]&&nowpeople*2>0&&nowpeople*2<=milk+1)
    {
        nowans++;
        vis[nowpeople*2]=1;
        dfs(nowpeople*2);
        nowans--;
        vis[nowpeople*2]=0;
    }
}

int main()
{
    people=read();
    milk=read();
    dfs(people);
    printf("%d",answer);
    return 0;
} 

广搜:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstdlib>

using namespace std;
const int N=100010;

struct node{
    int x,step;
}now,nxt,top;
int peo,milk;
bool vis[N];
queue<node>q;

inline int read()
{
    int x=0;char c=getchar();
    while(c<‘0‘||c>‘9‘)c=getchar();
    while(c>=‘0‘&&c<=‘9‘)x=x*10+c-‘0‘,c=getchar();
    return x;
}

inline void bfs(int start)
{
    now.x=start;
    now.step=0;
    q.push(now);
    while(!q.empty())
    {
        top=q.front();
        q.pop();
        int x=top.x;
        if(x==milk)
        {
            printf("%d\n",top.step);
            exit(0);
        }
        if(x+1>0&&x+1<=milk+1&&!vis[x+1])
        {
            vis[x+1]=1;
            nxt.x=x+1;
            nxt.step=top.step+1;
            q.push(nxt);
        }
        if(x-1>=0&&x-1<=milk+1&&!vis[x-1])
        {
            vis[x-1]=1;
            nxt.x=x-1;
            nxt.step=top.step+1;
            q.push(nxt);
        }
        if(x*2>=0&&x*2<=milk+1&&!vis[x*2])
        {
            vis[x*2]=1;
            nxt.x=x*2;
            nxt.step=top.step+1;
            q.push(nxt);
        }
    }
}

int main()
{
    peo=read();
    milk=read();
    bfs(peo);
    return 0;
}

简单:

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

using namespace std;

int a[100001],b[100001],c[100001];

int tot=0;

int print(int d)
{
    if(c[d]!=0) print(c[d]);
    tot++;
}
int main()
{
    memset(b,0,sizeof(b));
    memset(a,0,sizeof(a));
    int n,k,x;
    cin>>n>>k;
    if(n==k)
    {
        cout<<0<<endl;
        return 0;
    }

    a[1]=n;
    b[n]=1;
    int head=0,tail=1;

    while(head!=tail)
    {
        head++;
        for(int i=1; i<=3; ++i)
        {
            if(i==1) x=a[head]+1;
            if(i==2) x=a[head]-1;
            if(i==3) x=a[head]*2;
            if(x>=0&&b[x]==0&&x<=100000)
            {
                tail++;
                a[tail]=x;
                c[tail]=head;
                if(x==k)
                {
                    print(tail);
                    cout<<tot-1<<endl;
                    head=tail;
                    break;
                }
                b[x]=1;
            }
        }
    }
}

时间: 2024-10-12 14:31:16

2971:抓住那头牛的相关文章

2971 抓住那头牛 noi.openjudge

http://noi.openjudge.cn/ch0205/2971/ 总时间限制:  2000ms 内存限制:  65536kB 描述 农夫知道一头牛的位置,想要抓住它.农夫和牛都位于数轴上,农夫起始位于点N(0<=N<=100000),牛位于点K(0<=K<=100000).农夫有两种移动方式: 1.从X移动到X-1或X+1,每次移动花费一分钟 2.从X移动到2*X,每次移动花费一分钟 假设牛没有意识到农夫的行动,站在原地不动.农夫最少要花多少时间才能抓住牛? 输入 两个整数

OpenJudge 2971 抓住那头牛

总时间限制:  2000ms 内存限制:  65536kB 描述 农夫知道一头牛的位置,想要抓住它.农夫和牛都位于数轴上,农夫起始位于点N(0<=N<=100000),牛位于点K(0<=K<=100000).农夫有两种移动方式: 1.从X移动到X-1或X+1,每次移动花费一分钟 2.从X移动到2*X,每次移动花费一分钟 假设牛没有意识到农夫的行动,站在原地不动.农夫最少要花多少时间才能抓住牛? 输入 两个整数,N和K 输出 一个整数,农夫抓到牛所要花费的最小分钟数 样例输入 5 1

openjudge 2971:抓住那头牛 解题报告

总时间限制: 2000ms 内存限制:  65536kB 描述 农夫知道一头牛的位置,想要抓住它.农夫和牛都位于数轴上,农夫起始位于点N(0<=N<=100000),牛位于点K(0<=K<=100000).农夫有两种移动方式: 1.从X移动到X-1或X+1,每次移动花费一分钟. 2.从X移动到2*X,每次移动花费一分钟. 假设牛没有意识到农夫的行动,站在原地不动.农夫最少要花多少时间才能抓住牛? 输入 两个整数,N和K 输出 一个整数,农夫抓到牛所要花费的最小分钟数 样例输入 5

抓住那头牛

[题目描述] 农夫知道一头牛的位置,想要抓住它.农夫和牛都位于数轴上,农夫起始位于点N(0 <= N <= 100000),牛位于点K(0 <= K <= 100000).农夫有两种移动方式: (1)从X移动到X-1或X+1,每次移动花费一分钟: (2)从X移动到2*X,每次移动花费一分钟: 假设牛没有意识到农夫的行动,站在原地不动.农夫最少要花多少时间才能抓住牛? [输入描述] 输入两个整数N.K. [输出描述] 输出一个整数,农夫抓到牛所要花费的最小分钟数. [样例输入] 5

OpenJudge 4001:抓住那头牛

题目链接 题解: 这个题可以用广搜来解决,从农夫到牛的走法每次都有三种选择,定义一个队列,把农夫的节点加进队列,然后以这三种走法找牛,队列先进先出,按顺序直到找到牛的位置. 代码: #include<iostream> #include<stdio.h> #include<queue> #include<cstring> using namespace std; int n,k; #define MAX 1e5 const int MAX_N=1e5+5;

bfs 抓住那头牛

这是题目呀!http://ybt.ssoier.cn:8088/problem_show.php?pid=1253 算法分析:看到这道题目要求为最短时间,就可以判断用bfs(按照距开始状态由远及近的顺序进行搜索),而不是dfs. 在搜索过程中还可能遇到重复搜索的结果,这时我们就可以引入一个队列,使得已搜过的节点入队,再以此为下一层的父节点出队,以此往复. #include <iostream> #include<cstdio> #include <queue>#defi

抓住那头牛【题解】

一个玄学的广搜边界>=0,<=k+10,这个边界可能可以数学上证明,其他就是简单的广搜,然后输出步数,就可以了 #include <iostream> #include <cstdio> #include <fstream> #include <algorithm> #include <cmath> #include <deque> #include <vector> #include <queue>

codevs 3060 抓住那头奶牛 x

3060 抓住那头奶牛 USACO 时间限制: 1 s 空间限制: 16000 KB 题目等级 : 黄金 Gold 题目描述 Description 农夫约翰被告知一头逃跑奶牛的位置,想要立即抓住它,他开始在数轴的N 点(0≤N≤100000),奶牛在同一个数轴的K 点(0≤K≤100000). 约翰有两种移动方式:1 分钟内从x 点移动到x+1 或x-1:1 分钟内从x 点移动到2x.假设奶牛不会移动,约翰抓住它需要多少时间? 输入描述 Input Description 一行两个整数N 和K

双向广搜 codevs 3060 抓住那头奶牛

codevs 3060 抓住那头奶牛 USACO 时间限制: 1 s 空间限制: 16000 KB 题目等级 : 黄金 Gold 题目描述 Description 农夫约翰被告知一头逃跑奶牛的位置,想要立即抓住它,他开始在数轴的N 点(0≤N≤100000),奶牛在同一个数轴的K 点(0≤K≤100000).约翰有两种移动方式:1 分钟内从x 点移动到x+1 或x-1:1 分钟内从x 点移动到2x.假设奶牛不会移动,约翰抓住它需要多少时间? 输入描述 Input Description 一行两个