leetcode简单970

970. 强整数 给定两个正整数 x 和 y，如果某一整数等于 x^i + y^j，其中整数 i >= 0 且 j >= 0，那么我们认为该整数是一个强整数。 返回值小于或等于 bound 的所有强整数组成的列表。
     你可以按任何顺序返回答案。在你的回答中，每个值最多出现一次。 示例 1： 输入：x = 2, y = 3, bound = 10
     输出：[2,3,4,5,7,9,10]

最初的想法是顺序查看暴力提取，
没有注意到的是幂函数底数为1时不管幂是几都是1，这些情况都只需要经过1次

暴力法超时：

class Solution {//初始想法 未通过
public:
    vector<int> powerfulIntegers(int x, int y, int bound) {
        vector<int> count;
        for(int i=2;i<=bound;i++){
            if(isBigInt(x,y,i)){
                count.push_back(i);

                continue;
            }
        }
        return count;
    }
    int isBigInt(int a,int b,int p){
        int flag=0;
        for(int i=0;i<p;i++){
            for(int j=0;j<p;j++){
                if(pow(a,i)+pow(b,j)==p){
                    flag=1;
                    break;
                }
            }
        }
        return flag;
    }
};

修改后暴力法发现如果不提函数且底数为1的情况break，其实是可以不超时的：

class Solution {
public:
   public:
    vector<int> powerfulIntegers(int x, int y, int bound) {
        vector<int> count;
        for(int i=1;i<=bound;i*=x){//注意这里模仿幂函数，不是加一
            for(int j=1;j<bound;j*=y){
                if(i+j<=bound && (find(count.begin(), count.end(), i+j)==count.end())){

                        count.push_back(i+j);    

                }
                if(y==1) break;
            }
            if(x==1) break;
        }
        return count;
    }
   

};

他解1
和上面的思路基本一致，唯一的不同是使用了pow而非在循环做操作
unordered_set用法:https://blog.csdn.net/xiaoqiaxiaoqi/article/details/80531742

class Solution {
public:
   vector<int> powerfulIntegers(int x, int y, int bound) {
      unordered_set<int> c;
	  for(int i=0;;i++){
	  	int newone =(int)pow(x,i);
	  	if(newone >= bound){
	  		break;
		  }
		for(int j=0;;j++){
			int newtwo=(int)pow(y,j);
			if(newone+newtwo > bound) break;
			c.insert(newone+newtwo);
			if(y==1) break;//底数y为1的情况，不管是几次幂都为1，内层循环只需经过一次
		}
		if(x==1) break;//底数x为1情况同上，外层循环只需经过一次
	  } 
	  return vector<int>(c.begin(), c.end());

  }
};

他解2
使用了两个vector分别存放加号两边的变量，思路相对清晰
STL中不同容器之间是不能直接赋值的，assign()可以实现不同容器但相容的类型赋值

 vector<int> powerfulIntegers(int x, int y, int bound) {
        vector<int> result;
        if(bound < 2) return result;

        vector<int> xv, yv;
        xv.push_back(1);
        yv.push_back(1);
        int a = x, b = y;
        while(a != 1 && a < bound){
            xv.push_back(a);
            a *= x;
        }
        while(b != 1 && b < bound){
            yv.push_back(b);
            b *= y;
        }
        
        for(int& i : xv){
            for(int& j : yv){
                if(i + j <= bound){
                    result.push_back(i + j);
                }else{
                    break;
                }
            }
        }
        
        set<int> s(result.begin(), result.end());
        result.assign(s.begin(), s.end());

        return result;
    }