zoukankan      html  css  js  c++  java
  • java实现蓝桥杯密码脱落

    一 问题描述
    X星球的考古学家发现了一批古代留下来的密码。
    这些密码是由A、B、C、D 四种植物的种子串成的序列。
    仔细分析发现,这些密码串当初应该是前后对称的(也就是我们说的镜像串)。
    由于年代久远,其中许多种子脱落了,因而可能会失去镜像的特征。

    你的任务是:
    给定一个现在看到的密码串,计算一下从当初的状态,它要至少脱落多少个种子,才可能会变成现在的样子。

    输入一行,表示现在看到的密码串(长度不大于1000)
    要求输出一个正整数,表示至少脱落了多少个种子。

    例如,输入:
    ABCBA
    则程序应该输出:
    0

    再例如,输入:
    ABDCDCBABC
    则程序应该输出:
    3

    资源约定:
    峰值内存消耗(含虚拟机) < 256M
    CPU消耗 < 3000ms

    请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。

    所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
    注意:不要使用package语句。不要使用jdk1.7及以上版本的特性。
    注意:主类的名字必须是:Main,否则按无效代码处理。

    二 解决方案
    PS:第二个可能好理解一些

    在这里插入图片描述

    import java.util.Scanner;
    
    public class Main {
        public static String A;
        public static String backA;
        
        public int dfs(int lenA, int lenB) {
            if(lenA == -1 || lenB == -1)
                return 0;
            if(A.charAt(lenA) == backA.charAt(lenB))
                return dfs(lenA - 1, lenB - 1) + 1;
            else
                return Math.max(dfs(lenA - 1, lenB), dfs(lenA, lenB - 1));
        }
        
        public static void main(String[] args) {
            Main test = new Main();
            Scanner in = new Scanner(System.in);
            A = in.nextLine();
            backA = "";
            for(int i = A.length() - 1;i >= 0;i--)
                backA += A.charAt(i);
            int result = A.length() - test.dfs(A.length() - 1, backA.length() - 1);
            System.out.println(result);
        }
    }
    
     
    
    import java.util.Scanner;
    
    public class 密码脱落 {
        public static void main(String[] args) {
    
            Scanner scanner = new Scanner(System.in);
            char[] a = scanner.nextLine().toCharArray();
            code(a);
        }
    //左右坐标往中间走,直到i==j
        private static void code(char a[]) {
            int num = 0;
            int i = 0;//左面的坐标
            int n = 0;
            int m = 0;
            int j = a.length - 1;//右面的坐标
            while (i <= j) {
                n = 0;
                m = 0;
                //相等
                if (a[i] == a[j]) {
                    i++;
                    j--;
                } else {
                    //不相等
                    //循环的终止条件就是左面坐标的值和右面坐标的值相等
                    int tj = j;//找个临时变量
                    while (a[i] != a[tj]) {
                        tj--;//右面的往左走
                        n++;//记录走的步数
                    }
                    int ti = i;//找个临时变量
                    while (a[ti] != a[j]) {
                        ti++;//左面的往右走
                        m++;//记录走了几步
                    }
                    if (n < m) {//看看哪个步数少,就用哪个
                        //n<m说明左面走的步数多
                        j -= n;
    
                    } else {
                        //相反
                        i += m;
    
                    }
                    //num为总的修改数,经过上面的比较,哪个修改数少就采用哪一个
                    num += n < m ? n : m;
                }
            }
            System.out.println(num);
        }
    }
    
    
    
  • 相关阅读:
    LeetCode 227. Basic Calculator II
    LeetCode 224. Basic Calculator
    LeetCode 103. Binary Tree Zigzag Level Order Traversal
    LeetCode 102. Binary Tree Level Order Traversal
    LeetCode 106. Construct Binary Tree from Inorder and Postorder Traversal
    LeetCode 105. Construct Binary Tree from Preorder and Inorder Traversal
    LeetCode 169. Majority Element
    LeetCode 145. Binary Tree Postorder Traversal
    LeetCode 94. Binary Tree Inorder Traversal
    LeetCode 144. Binary Tree Preorder Traversal
  • 原文地址:https://www.cnblogs.com/a1439775520/p/13078268.html
Copyright © 2011-2022 走看看