输入两个数m,n两个数,只允许加一和乘二运算，变成另两个输入的数targetX，targetY

之前笔试的时候遇到的一道题，没做出来。没得到面试机会。当我掌握了回溯算法之后我才算懂得怎么了解开这道题。

首先，可以把题目简化一下：输入一个数num，只允许加一和乘二运算，变成另一个数target

输入num=3，target=13；经过3*2*2+1=13

图中表示回溯算法的过程，方框中的1表示进行加1运算，2表示乘2运算，括号中的值表示运算后的结果

该过程通过代码表示为

package test2;

import java.awt.image.RescaleOp;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Cheng2jia2 {
	static List<List<Integer>> res=new ArrayList<List<Integer>>();
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		while(sc.hasNext()) {
			int num=sc.nextInt();
			int target=sc.nextInt();
			List<Integer> tem=new ArrayList<Integer>();
			dfs(num, target, tem);
			int min=Integer.MAX_VALUE;
			List<Integer> resList=new ArrayList<Integer>();
            //求出长度最小的list，即为结果
			for(int i=0;i<res.size();i++) {
				List list= res.get(i);
				if(list.size()<min) {
					min=list.size();
					resList=list;
				}
			}
			System.out.println(resList.size());
			System.out.println(resList);
			res.clear();
		}
		
	}
	public static void dfs(int num,int target,List tem) {
        #当num大于或等于target时，退出递归
		if(num==target) {
			res.add(new ArrayList<Integer>(tem));
			return;
		}else if (num>target) {
			return;
		}
		for(int i=1;i<=2;i++) {
			if(i==1) {
				tem.add(i);
                //加1运算
				dfs(num+1, target, tem);
				tem.remove(tem.size()-1);
			}else if(i==2){
				tem.add(i);
                //乘2运算
				dfs(num*2, target, tem);
				tem.remove(tem.size()-1);
			}
		}
	}
}

 控制台中输入3   13，输出如下，输出第一行为最小运算次数，第二行为运算过程，2表示乘2,1表示加1。

 

 那么，回到原题，输入两个数m,n两个数,只允许加一和乘二运算，变成另两个输入的数targetX，targetY。如果m和targetX进行一次上述过程得到运算过程的list集合，n再和targetY进行一次上述的代码运算，再进行比较两次得到的list的话，得到的结果可能会有偶然性。

更稳妥的办法应该是通过m和targetX比较得到的list，对targetY进行逆序运算，如果targetY根据list，逆序运算的到的结果与n一致，则返回list的size即为运算的最小次数。若结果和n不相等，则返回-1。

import java.awt.image.RescaleOp;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Cheng2jia2Plus {
	static List<List<Integer>> res=new ArrayList<List<Integer>>();
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		
			int num1=sc.nextInt();
			int num2=sc.nextInt();
			int targetX=sc.nextInt();
			int targetY=sc.nextInt();
			List<Integer> tem=new ArrayList<Integer>();
			dfs(num1, targetX, tem);
			int min=Integer.MAX_VALUE;
			List<Integer> resList=new ArrayList<Integer>();
			for(int i=0;i<res.size();i++) {
				List list= res.get(i);
				if(list.size()<min) {
					min=list.size();
					resList=list;
				}
			}
            //逆序对targetY进行运算，遇到1就减1，遇到2就先判断是否为偶数，不为偶数则返回-1，为偶数则除2.
			for(int i=resList.size()-1;i>=0;i--) {
				if(resList.get(i)==1) {
					targetY=targetY-1;
				}else if (resList.get(i)==2) {
					if(targetY%2==1) {
						System.out.println("-1");
						return;
					}else {
						targetY=targetY/2;
					}
				}
			}
			//最后进行比较，根据list逆序运算后的targetY如果和n相等，则输出最小运算次数，如果不相等则输出-1.
			if(targetY==num2) {
				System.out.println(resList.size());
			}else {
				System.out.println("-1");
			}
			
			
			
		
		
	}
	public static void dfs(int num,int target,List tem) {
		if(num==target) {
			res.add(new ArrayList<Integer>(tem));
			return;
		}else if (num>target) {
			return;
		}
		for(int i=1;i<=2;i++) {
			if(i==1) {
				tem.add(i);
				dfs(num+1, target, tem);
				tem.remove(tem.size()-1);
			}else if(i==2){
				tem.add(i);
				dfs(num*2, target, tem);
				tem.remove(tem.size()-1);
			}
		}
	}
}