9.30

今日份热气腾腾的程序来了~~~~~

78. 子集（通过）

思路：

数搜索，同样的思路已经见过很多次了，但是效果可能不是很好

效率：

战胜100%的用户

程序代码：

#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<sstream>
#include<stack>//引入数据结构堆栈
//78、子集
//思路一：树搜索
using namespace std;

class Solution {
public:
	vector<vector<int>> subsets(vector<int>& nums) {
		vector<vector<int>> result;//最终形成的结果
		vector<int> vec;//表示中间形成的向量
		Haha(result, vec,0,nums);
		return result;
	}
	void Haha(vector<vector<int>> &result, vector<int> &vec, int index,vector<int> &nums) {
		int n = nums.size();
		if (index==n+1)
			result.push_back(vec);
		else {

			for (int i = index; i <= n; i++) {
				if(i!=n) vec.push_back(nums[i]);
				Haha(result, vec, i + 1, nums);
				if(i!=n) vec.pop_back();
			}

		}
	}

};



int main()
{
	Solution bb;
	int count;//表示数字的个数
	cin >> count;
	vector<int> nums(count);
	for (int i = 0; i < count; i++) {
		cin >> nums[i];
	}
	vector<vector<int>> result=bb.subsets(nums);
	int m = result.size();
	//进行输出
	for (int i=0; i < m; i++) {
		for (int j = 0; j < result[i].size(); j++) {
			cout << result[i][j] << " ";
		}
		cout << endl;
	}
	return 0;
}

效率居然战胜了100%的用户，好诡异，可能这道题最优的解法就是递归。

标准答案是深度优先搜索：

class Solution {
public:
	void dfs(vector<vector<int>> &res, vector<int> &nums, vector<int> temp, int i)
	{
		if (i == nums.size())
		{
			res.push_back(temp);
			return;
		}

		dfs(res, nums, temp, i + 1);
		temp.push_back(nums[i]);
		dfs(res, nums, temp, i + 1);
	}

	vector<vector<int>> subsets(vector<int>& nums)
	{
		vector<vector<int>> res;
		vector<int> temp;

		dfs(res, nums, temp, 0);

		return res;
	}
};

556. 下一个更大元素 III

思路：

和之前见过的一道题一毛一样

效率：

战胜了100%的用户，哈哈哈哈

注意点：

这是在32的机器上，int类型有一位表示正负号，因此真正能表示的最大数值是2147483647，溢出的也算是不存在。

程序代码：

#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<sstream>
#include<stack>//引入数据结构堆栈
//556. 下一个更大元素 III
//表示这道题目非常熟悉，之前见过
using namespace std;

class Solution {
public:
	int nextGreaterElement(int n) {
		string s = to_string(n);//本体必须转变成为字符串进行处理
		int m = s.size();
		int index = -1;//标志什么位置开始变小
		int k;
		for (int i = m - 2; i >= 0; i--) {
			if (s[i] < s[i + 1]) {
				index = i;
				break;//直接退出
			}
		}
		if (index == -1) return -1;//说明没有字符串是最大的了，没有再比这个大的数字了
		else {
			sort(s.begin() + index+1, s.end());//只需对于后面的元素按照从小到大的顺序排列即可
			for (int i = index + 1; i < m; i++) {
				if (s[i] > s[index]) {
					k = i;
					break;
				}
			}
			swap(s[index],s[k]);
		}
		
		return Trans(s,n);
	}

	int Trans(string s,int n) {
		
		int a = 0;
		int sum = 0;//表示累积的加和
		for (char e : s) {
			a = int(e-'0');
			sum = 10*sum + a;
		}
		if (sum < n) return -1;
		else 
		return sum;
	}

	void swap(char &a, char &b) {//直接使用字符形式，没什么影响
		char tmp = a;
		a = b;
		b = tmp;
	}
};


int main()
{
	Solution bb;
	int n;
	cin >> n;
	int result=bb.nextGreaterElement(n);
	cout<<result<<endl;
	return 0;
}

在字符串转变成为长整形的过程中可以使用long long res=stoll(s);
标准答案的解法如下：我们的效率都是100%奥

class Solution {
public:
    int nextGreaterElement(int n) {
        string s=to_string(n);
        int size=s.size()-1;
        int i=size;
        for(;i>0;i--){
            if(s[i]>s[i-1]) break;
        }
        if(i==0) return -1;
        i--;
        for(int j=size;j>i;j--){
            if(s[j]>s[i]){
                swap(s[j],s[i]);
                break;
            }
        }
        sort(s.begin()+i+1,s.end());
        long long res=stoll(s);
        return res>INT_MAX?-1:res;
    }
};