class Solution {
public:
void nextPermutation(vector<int>& nums) {
for(int i = nums.size() - 1; i; i --)
{
if(nums[i - 1] < nums[i])
{
int j = i;
while(j + 1 < nums.size() && nums[j + 1] > nums[i - 1]) j++;
swap(nums[i - 1], nums[j]);
reverse(nums.begin() + i, nums.end());
return ;
}
}
reverse(nums.begin(), nums.end()); //不存在，降序=>升序
}
};
class Solution {
public:
int longestValidParentheses(string s) {
if(s.size() == 0) return 0;
stack<int> stk;
stk.push(-1);
int res = 0;
for(int i = 0; i < s.size(); i ++)
{
if(s[i] == '(') stk.push(i);
else
{
stk.pop();
if(stk.empty()) stk.push(i);
else res = max(res, i - stk.top());
}
}
return res;
}
};
class Solution {
public:
int search(vector<int>& nums, int target) {
if(nums.size() == 0) return -1;
int left = 0, right = nums.size() - 1;
if(nums[0] > nums.back())
{
int l = 0, r = nums.size() - 1;
while(l < r)
{
int mid = l + r + 1>> 1;
if(nums[mid] >= nums[0]) l = mid;
else r = mid - 1;
}
if(target < nums[0]) left = l + 1, right = nums.size() - 1;
else left = 0, right = l;
}
while(left < right)
{
int mid = left + right >> 1;
if(nums[mid] >= target) right = mid;
else left = mid + 1;
}
if(nums[left] == target) return left;
return -1;
}
};
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target) {
//二分上界和下界
vector<int> res;
int l = 0, r = nums.size() - 1;
while(l < r)
{
int mid = l + r >> 1;
if(nums[mid] >= target) r = mid;
else l = mid + 1;
}
if(nums.empty() || nums[r] != target)
{
res.push_back(-1);
res.push_back(-1);
return res;
}
res.push_back(l);
l = 0, r = nums.size() - 1;
while(l < r)
{
int mid = l + r + 1 >> 1;
if(nums[mid] <= target) l = mid;
else r = mid - 1;
}
res.push_back(l);
return res;
}
};
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int l = 0, r = nums.size() - 1;
while(l < r)
{
int mid = l + r >> 1;
if(nums[mid] >= target) r = mid;
else l = mid + 1;
}
if(nums[l] < target) return nums.size();
return r;
}
};
class Solution {
public:
bool isValidSudoku(vector<vector<char>>& board) {
vector<vector<int>> rows(9, vector<int>(9, 0));
vector<vector<int>> cols(9, vector<int>(9, 0));
vector<vector<int>> blocks(9, vector<int>(9, 0));
for(int i = 0; i < 9; i ++)
for(int j = 0; j < 9; j ++)
if(board[i][j] != '.')
{
int num = board[i][j] - '1';
int blockIndex = i / 3 * 3 + j / 3;
if(rows[i][num] || cols[j][num] || blocks[blockIndex][num])
return false;
else{
rows[i][num] = 1;
cols[j][num] = 1;
blocks[blockIndex][num] = 1;
}
}
return true;
}
};
class Solution {
public:
bool row[9][9], col[9][9], st[3][3][9];
void solveSudoku(vector<vector<char>>& board) {
memset(row, 0, sizeof row);
memset(col, 0, sizeof col);
memset(st, 0, sizeof st);
for(int i = 0; i < 9; i ++)
for(int j = 0; j < 9; j ++)
if(board[i][j] != '.')
{
int v = board[i][j] - '1';
row[i][v] = col[j][v] = st[i / 3][j / 3][v] = true;
}
dfs(board, 0, 0);
}
bool dfs(vector<vector<char>>&board, int x, int y)
{
if(y == 9) y = 0, x ++;
if(x == 9) return true;
if(board[x][y] != '.') return dfs(board, x, y + 1);//一列一列遍历
for(int i = 0; i < 9; i ++)
{
if(board[x][y] == '.' && !row[x][i] && !col[y][i] && !st[x/3][y/3][i])
{
board[x][y] = '1' + i;
row[x][i] = col[y][i] = st[x/3][y/3][i] = true;
if(dfs(board, x, y + 1)) return true;
board[x][y] = '.';
row[x][i] = col[y][i] = st[x/3][y/3][i] = false;
}
}
return false;
}
};
class Solution {
public:
string countAndSay(int n) {
string s = "1";
for(int i = 1; i < n; i ++)
{
string ns = "";
for(int j = 0; j < s.size(); )
{
int u = j; //记录重复的字符
while(u < s.size() && s[u] == s[j]) u ++;
ns += to_string(u - j);
ns += s[j];
j = u;
}
s = ns;
}
return s;
}
};
class Solution {
public:
vector<vector<int>> res;
vector<int> path;
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
dfs(candidates, 0, target);
return res;
}
void dfs(vector<int>& c, int u, int t)
{
if(u == c.size())
{
if(!t) res.push_back(path);
return;
}
dfs(c, u + 1, t);
while(t >= c[u])
{
path.push_back(c[u]);
t -= c[u];
dfs(c, u + 1, t);
}
while(path.size() && path.back() == c[u]) path.pop_back();
}
};
class Solution {
public:
vector<vector<int>> res;
vector<int> path;
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
sort(candidates.begin(), candidates.end());
dfs(candidates, 0, target);
return res;
}
void dfs(vector<int>& c, int u, int t)
{
if(t < 0) return ;
if(t == 0) res.push_back(path);
else for(int i = u; i < c.size(); i ++)
{
if(i != u && c[i] == c[i - 1]) continue;
path.push_back(c[i]);
dfs(c, i + 1, t - c[i]);
path.pop_back();
}
}
};
