2014百度校招深圳站笔试题

题目描述： 输入任意正整数，比这个数大的最小不重复数（相邻两个数字不重复），例如1101是重复，1234不重复，1201不重复。
解题思路：先将number加1，然后判断是否有数字重复，有重复继续将number加1。
这是一种暴力的解法，如果输入的数字为111111111的话，那么累计需要加上百万次。

<span style="font-size:14px;">public class UnrepeatedValue {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        solution(scanner.nextInt());
    }
    public static void solution(int number){
        String num=String.valueOf(number+1);
        if(num.length()==1){
            System.out.println(num);
        }else{
            boolean flag=true;
            while(flag){
                for(int i=0;i
                    if(num.charAt(i)==num.charAt(i+1)){
                        break;
                    }else{
                        if(i==num.length()-2){
                            System.out.println(num);
                            flag=false;
                        }
                    }
                }
                number++;
                num=String.valueOf(number);
            }
        }
    }
}</span>

上面对于这个问题采用暴力解法，显然是不行的。这里提供一个优化的版本，大体思路为，从右往左判断number+1。如果两个数字重复，则直接将这两个数取出来加1。然后将这个数后面的数置为010101系列...
注：这种解法也不是最优解。从右往左遍历，当遍历到高位了以后，低位的值还是重新置为0101系列，那么之前对低位的操作相当于是冗余了。所以最优解应该是从左往右遍历

从右往左遍历：

<span style="font-size:14px;">public class Unrepeated {
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        System.out.println(hasRepeated(s.nextLong()));
    }
    public static long hasRepeated(long number){
        String num=String.valueOf(number+1);
        long n;
        long result=0;
        while((n=merge(new StringBuilder(num)))!=0){
            num=String.valueOf(n);
            result=n;
        }
        if(result==0){       //判断当number+1不需要merge的时候直接返回number+1。
            return number+1;
        }else{
            return result;
        }
    }
    public static long merge(StringBuilder s){
        for(int i=s.length()-1;i>0;i--){
            if(s.charAt(i)==s.charAt(i-1)){
                long l=Long.parseLong(String.valueOf(s.charAt(i-1)+String.valueOf(s.charAt(i))))+1;
                int m=s.length()-i-1;
                for(int j=0;j
                    l*=10;
                }
                s.setCharAt(i,'0');
                s.setCharAt(i-1,'0');
                long num=Long.parseLong(s.toString())+l;
                s=new StringBuilder(String.valueOf(num));
                //将后面的数置为0101系列.
                for(int t=i+1;t
                    for(int j=0;j<2;j++){
                        if(s.charAt(t-1)!=(j+48)){
                            s.setCharAt(t, (char) (j+48)); //0的ASCII码为48
                            break;
                        }
                    }
                }
                return Long.parseLong(s.toString());
            }
        }
        return 0;
    }
}</span>

从左往右遍历，其实写法和上面差不多，但是这应该是最高效的吧

<span style="font-size:14px;">package org.whut.choumiaoer.interview;

import java.util.Scanner;

public class UnRepeat {
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        System.out.println(hasRepeated(s.nextLong()));
    }
    public static long hasRepeated(long number){
        String num=String.valueOf(number+1);
        long n;
        long result=0;
        while ((n=merge(new StringBuilder(num)))!=0){
            num= String.valueOf(n);
            result=n;
        }
        if(result==0){
            return number+1;
        }else {
            return result;
        }
    }
    public static long merge(StringBuilder s){
        for(int i=0;i
            if(s.charAt(i)==s.charAt(i+1)){
                long l=Long.parseLong(String.valueOf((s.charAt(i))+String.valueOf(s.charAt(i+1))))+1;
                int m=s.length()-2-i;//判定需要乘以10的多少次方
                s.setCharAt(i,'0');
                s.setCharAt(i+1,'0');
                for(int j=0;j
                    l*=10;
                }
                long num=l+Long.parseLong(s.toString());
                s=new StringBuilder(String.valueOf(num));
                for(int t=i+2;t
                    for(int j=0;j<2;j++){
                        if(s.charAt(t-1)!=(j+48)){
                            s.setCharAt(t, (char) (j+48));
                            break;             //如果没有break的话，就会变成1010序列
                        }
                    }
                }
                return Long.parseLong(s.toString());
            }
        }
        return 0;
    }
}</span>