zoukankan      html  css  js  c++  java
  • HDU 汉诺塔VII

    汉诺塔VII

    Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
    Total Submission(s): 203 Accepted Submission(s): 174
    Problem Description
    n个盘子的汉诺塔问题的最少移动次数是2^n-1,即在移动过程中会产生2^n个系列。由于发生错移产生的系列就增加了,这种错误是放错了柱子,并不会把大盘放到小盘上,即各柱子从下往上的大小仍保持如下关系 :
    n=m+p+q
    a1>a2>...>am
    b1>b2>...>bp
    c1>c2>...>cq
    ai是A柱上的盘的盘号系列,bi是B柱上的盘的盘号系列, ci是C柱上的盘的盘号系列,最初目标是将A柱上的n个盘子移到C盘. 给出1个系列,判断它是否是在正确的移动中产生的系列.
    例1:n=3
    3
    2
    1
    是正确的
    例2:n=3
    3
    1
    2
    是不正确的。
    注:对于例2如果目标是将A柱上的n个盘子移到B盘. 则是正确的.
     
    Input
    包含多组数据,首先输入T,表示有T组数据.每组数据4行,第1行N是盘子的数目N<=64.
    后3行如下
    m a1 a2 ...am
    p b1 b2 ...bp
    q c1 c2 ...cq
    N=m+p+q,0<=m<=N,0<=p<=N,0<=q<=N,
     
    Output

                对于每组数据,判断它是否是在正确的移动中产生的系列.正确输出true,否则false
     
    Sample Input
    6
    3
    1 3
    1 2
    1 1
    3
    1 3
    1 1
    1 2
    6
    3 6 5 4
    1 1
    2 3 2
    6
    3 6 5 4
    2 3 2
    1 1
    3
    1 3
    1 2
    1 1
    20
    2 20 17
    2 19 18
    16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
     
    Sample Output
    true
    false
    false
    false
    true
    true
     
     
    #include <iostream>
    #include <stdio.h>
    using namespace std;
    int main()
    {
        int one[4],n[4],h[4][64],a,b,c,N,cas,i,t,flag;
        scanf("%d",&cas);
        while(cas--)
        {
            a = 1;b = 2;c = 3;
            one[a]=one[b]=one[c]=1;
            scanf("%d",&N);
            scanf("%d",&n[a]);
            for(i = one[a];i<=n[a];i++)
            scanf("%d",&h[a][i]);
            scanf("%d",&n[b]);
            for(i = one[b];i<=n[b];i++)
            scanf("%d",&h[b][i]);
            scanf("%d",&n[c]);
            for(i = one[c];i<=n[c];i++)
            scanf("%d",&h[c][i]);
            flag = 1;
            while(true)
            {
                if(n[b]>0&&h[b][one[b]]==N){flag = 0;break;}
                if(n[c]==N||n[a]==N){flag = 1;break;}
                if(n[a]>0&&h[a][one[a]]==N)
                {
                    N--;
                    n[a]--;
                    one[a]++;
                    t = b; b = c;c = t;
                    continue;
                }
                if(n[c]>0&&h[c][one[c]]==N)
                {
                    N--;
                    n[c]--;
                    one[c]++;
                    t = a;a = b;b = t;
                    continue;
                }
            }
            if(flag)printf("true\n");
            else printf("false\n");
        }
        return 0;
    }
  • 相关阅读:
    POJ-1189 钉子和小球(动态规划)
    POJ-1191-棋盘分割(动态规划)
    Java实现 LeetCode 730 统计不同回文子字符串(动态规划)
    Java实现 LeetCode 730 统计不同回文子字符串(动态规划)
    Java实现 LeetCode 729 我的日程安排表 I(二叉树)
    Java实现 LeetCode 729 我的日程安排表 I(二叉树)
    Java实现 LeetCode 729 我的日程安排表 I(二叉树)
    Java实现 LeetCode 728 自除数(暴力)
    Java实现 LeetCode 728 自除数(暴力)
    Java实现 LeetCode 728 自除数(暴力)
  • 原文地址:https://www.cnblogs.com/newpanderking/p/2120984.html
Copyright © 2011-2022 走看看