A Broken Calculator 最详细的解题报告

  1 import java.math.BigInteger;
  2 import java.util.Arrays;
  3 import java.util.Scanner;
  4 
  5 public class Main{
  6     
  7     public int[]available;
  8     public String target;
  9     public int limited;
 10     
 11     public Main(String target,int limited){
 12         this.available=new int[10];
 13         this.target=target;
 14         this.limited=limited;
 15     }
 16     private int getIntByIndex(int index){
 17         return this.target.charAt(index)-‘0‘;
 18     }
 19     
 20     private BigInteger substract(String str1,String str2){
 21         BigInteger a=new BigInteger(str1);
 22         BigInteger b=new BigInteger(str2);
 23         if(a.compareTo(b)>0){
 24             return a.subtract(b);
 25         }else{
 26             return b.subtract(a);
 27         }
 28     }
 29     private String convertTo(int[]array){
 30         StringBuffer buffer=new StringBuffer();
 31         for(int i=0;i<array.length;i++){
 32             buffer.append(array[i]);
 33         }
 34         return buffer.toString();
 35     }
 36     
 37     public void solve(){
 38         int index=0;
 39         int k=this.limited;
 40         for(;index<this.target.length();index++){            
 41             int j=this.getIntByIndex(index);
 42             if(this.available[j]==0){
 43                 if(k==0){
 44                     break;
 45                 }
 46                 this.available[j]=1;
 47                 k--;
 48             }            
 49         }
 50         if(index==this.target.length()){
 51             System.out.println("0");
 52             return;
 53         }
 54         int[]copy=Arrays.copyOf(this.available, this.available.length);
 55         BigInteger diff1=this.substract(this.convertTo(this.calculateMax(copy, index)), this.target);
 56         BigInteger diff2=this.substract(this.target,this.convertTo(this.calculateMin(this.available, index)));
 57         if(diff1.compareTo(diff2)>0){
 58             System.out.println(diff2.toString());
 59         }else{
 60             System.out.println(diff1.toString());
 61         }
 62     }
 63     
 64     private int getValue(int[] avail,boolean less){
 65         if(less){
 66             for(int i=0;i<=9;i++){
 67                 if(avail[i]>0)
 68                     return i;
 69             }
 70         }else{
 71             for(int i=9;i>=0;i--){
 72                 if(avail[i]>0)
 73                     return i;
 74             }
 75         }
 76         return -1;
 77     }
 78     
 79     public int[] calculateMax(int[] avail,int index){
 80         int[]result=new int[this.target.length()];
 81         int nextValue=Integer.MIN_VALUE;
 82         for(int i=0;i<index;i++){
 83             result[i]=this.getIntByIndex(i);
 84         }
 85         for(int i=0;i<=9;i++){
 86             if(avail[i]>0&&i>this.getIntByIndex(index)){
 87                 nextValue=i;
 88                 break;
 89             }
 90         }
 91         if(nextValue==Integer.MIN_VALUE){
 92             nextValue=this.getIntByIndex(index-1)+1;
 93             for(int j=index-1;j>=0;j--){
 94                 if(result[j]==nextValue-1){
 95                     result[j]=nextValue;
 96                 }
 97             }
 98             result[index-1]=nextValue;
 99             avail[nextValue-1]=0;
100             int min=Integer.MAX_VALUE;
101             if(avail[nextValue]==0){
102                 avail[nextValue]=1;
103                 min=this.getValue(avail, true);
104             }
105             for(int j=index;j<this.target.length();j++){
106                 result[j]=min;
107             }
108         }else{
109             result[index] = nextValue;
110             int min=this.getValue(avail, true);
111             for(int i = index + 1; i < result.length; i++)
112             {
113                 result[i] = min;
114             }
115         }
116         return result;
117     }
118     
119     public int[] calculateMin(int[] avail,int index){
120         int[]result=new int[this.target.length()];
121         int nextValue=Integer.MIN_VALUE;
122         for(int i=0;i<index;i++){
123             result[i]=this.getIntByIndex(i);
124         }
125         for(int i=9;i>=0;i--){
126             if(avail[i]>0&&i<this.getIntByIndex(index)){
127                 nextValue=i;
128                 break;
129             }
130         }
131         if(nextValue==Integer.MIN_VALUE){
132             if(index==1&&this.getIntByIndex(0)==1){
133                 result=new int[this.target.length()-1];
134                 for(int j=0;j<result.length;j++){
135                     result[j]=9;
136                 }
137             }else{
138                 nextValue=this.getIntByIndex(index-1)-1;
139                 for(int j=index-1;j>=0;j--){
140                     if(result[j]==nextValue+1){
141                         result[j]=nextValue;
142                     }
143                 }
144                 result[index-1]=nextValue;
145                 avail[nextValue+1]=0;
146                 int max=Integer.MIN_VALUE;
147                 if(avail[nextValue]==0){
148                     avail[nextValue]=1;
149                     max=this.getValue(avail, false);
150                 }
151                 for(int j=index;j<this.target.length();j++){
152                     result[j]=max;
153                 }
154             }
155         }else{
156             result[index] = nextValue;
157             int max=this.getValue(avail, false);
158             for(int i = index + 1; i < result.length; i++)
159             {
160                 result[i] = max;
161             }
162         }
163         return result;
164     }
165     
166     public static void main(String[] args) {
167         Scanner scanner=new Scanner(System.in);
168         Main m=new Main(scanner.next(),scanner.nextInt());
169         m.solve();
170     }
171 }