长度为三且各字符不同的子字符串
如果一个字符串不含有任何重复字符，我们称这个字符串为 好 字符串。
给你一个字符串 s ，请你返回 s 中长度为 3 的 好子字符串 的数量。
注意，如果相同的好子字符串出现多次，每一次都应该被记入答案之中。
子字符串 是一个字符串中连续的字符序列。
示例 1：
输入：s = “xyzzaz”
输出：1
解释：总共有 4 个长度为 3 的子字符串：“xyz”，“yzz”，“zza” 和 “zaz” 。
唯一的长度为 3 的好子字符串是 “xyz” 。
示例 2：
输入：s = “aababcabc”
输出：4
解释：总共有 7 个长度为 3 的子字符串：“aab”，“aba”，“bab”，“abc”，“bca”，“cab” 和 “abc” 。
好子字符串包括 “abc”，“bca”，“cab” 和 “abc” 。
提示：
1 <= s.length <= 100
s 只包含小写英文字母。
模拟题，根据题目意思模拟一遍就可以了。
class Solution {
public:
bool check(string s)
{
unordered_map<char,int>h;
for(auto x:s)
{
if(!h[x])h[x]++;
else return false;
}
return true;
}
int countGoodSubstrings(string s) {
int len=s.size();
int cnt=0;
for(int i=0;i<len-2;i++)
{
string str=s.substr(i,3);
if(check(str))cnt++;
}
return cnt;
}
};
数组中最大数对和的最小值
一个数对 (a,b) 的 数对和 等于 a + b 。最大数对和 是一个数对数组中最大的 数对和 。
比方说，如果我们有数对 (1,5) ，(2,3) 和 (4,4)，最大数对和 为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8 。
给你一个长度为 偶数 n 的数组 nums ，请你将 nums 中的元素分成 n / 2 个数对，使得：
nums 中每个元素 恰好 在 一个 数对中，且
最大数对和 的值 最小 。
请你在最优数对划分的方案下，返回最小的 最大数对和 。
示例 1：
输入：nums = [3,5,2,3]
输出：7
解释：数组中的元素可以分为数对 (3,3) 和 (5,2) 。
最大数对和为 max(3+3, 5+2) = max(6, 7) = 7 。
示例 2：
输入：nums = [3,5,4,2,4,6]
输出：8
解释：数组中的元素可以分为数对 (3,5)，(4,4) 和 (6,2) 。
最大数对和为 max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8 。
这题除了猜得出，也没别的做法了吧。
class Solution {
public:
int minPairSum(vector<int>& nums) {
sort(nums.begin(),nums.end());
int ans=-1;
for(int i=0,j=nums.size()-1;i<j;i++,j--)
{
ans=max(ans,nums[i]+nums[j]);
}
return ans;
}
};
矩阵中最大的三个菱形和
给你一个 m x n 的整数矩阵 grid 。
菱形和 指的是 grid 中一个正菱形 边界 上的元素之和。本题中的菱形必须为正方形旋转45度，且四个角都在一个格子当中。下图是四个可行的菱形，每个菱形和应该包含的格子都用了相应颜色标注在图中。
注意，菱形可以是一个面积为 0 的区域，如上图中右下角的紫色菱形所示。
请你按照 降序 返回 grid 中三个最大的 互不相同的菱形和 。如果不同的和少于三个，则将它们全部返回。
示例 1：
输入：grid = [[3,4,5,1,3],[3,3,4,2,3],[20,30,200,40,10],[1,5,5,4,1],[4,3,2,2,5]]
输出：[228,216,211]
解释：最大的三个菱形和如上图所示。
- 蓝色：20 + 3 + 200 + 5 = 228
- 红色：200 + 2 + 10 + 4 = 216
- 绿色：5 + 200 + 4 + 2 = 211
示例 2：
输入：grid = [[1,2,3],[4,5,6],[7,8,9]]
输出：[20,9,8]
解释：最大的三个菱形和如上图所示。
- 蓝色：4 + 2 + 6 + 8 = 20
- 红色：9 （右下角红色的面积为 0 的菱形）
- 绿色：8 （下方中央面积为 0 的菱形）
示例 3：
输入：grid = [[7,7,7]]
输出：[7]
解释：所有三个可能的菱形和都相同，所以返回 [7] 。
提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 100
1 <= grid[i][j] <= 105
class Solution {
public:
int lenn,lenm;
bool check(int x,int y)
{
if(x>=0&&x<lenn&&y>=0&&y<lenm)return true;
return false;
}
vector<int> getBiggestThree(vector<vector<int>>& grid) {
lenm=grid[0].size();
lenn=grid.size();
// cout<<lenn<<" "<<lenm<<endl;
vector<int>nums;
for(int x=0;x<lenn;x++)
{
for(int y=0;y<lenm;y++)
{
for(int l=1;l<=min(lenm,lenn);l++)
{
if(l!=1)
{
int t=l-1;
int xl=x+t,yl=y-t;
int xr=x+t,yr=y+t;
int xu=x+(t*2),yu=y;
if(check(xl,yl)&&check(xr,yr)&&check(xu,yu))
{
int sum=0;
sum=grid[x][y]+grid[xl][yl]+grid[xr][yr]+grid[xu][yu];
int di=t-1;
for(int k=1;k<=di;k++){
sum+=grid[x+k][y-k];
}
for(int k=1;k<=di;k++){
sum+=grid[x+k][y+k];
}
for(int k=1;k<=di;k++){
sum+=grid[xl+k][yl+k];
}
for(int k=1;k<=di;k++){
sum+=grid[xr+k][yr-k];
}
nums.push_back(sum);
// if(sum==210)
// {
// cout<<x<<" "<<y<<" "<<l<<endl;
// cout<<xl<<" "<<yl<<endl;
// cout<<xr<<" "<<yr<<endl;
// cout<<xu<<" "<<yu<<endl;
// return {210};
// }
}
}
else nums.push_back(grid[x][y]);
}
}
}
sort(nums.begin(),nums.end());
reverse(nums.begin(),nums.end());
// for(int k=0;k<nums.size();k++)cout<<nums[k]<<endl;
vector<int>ans;
unordered_map<int,int>h;
for(auto x:nums)
{
if(!h[x])
{
ans.push_back(x);
h[x]++;
}
}
vector<int>res;
if(ans.size()<3)return ans;
else
{
res.push_back(ans[0]);
res.push_back(ans[1]);
res.push_back(ans[2]);
}
return res;
}
};
在看了y总的视频讲解之后，感觉自己的写法时间复杂度太大，y总在使用到了一个类似前缀和的方法，可以在o(1)的时间复杂度里面求出一条线上的数字的和，然后枚举，也可以枚举中心点和半径，比我上面的枚举最低点和边长更容易一点，把y总代码贴上来
const int N = 110;
int s1[N][N], s2[N][N];
class Solution {
public:
vector<int> getBiggestThree(vector<vector<int>>& g) {
int n = g.size(), m = g[0].size();
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= m; j ++ ) {
s1[i][j] = s1[i - 1][j - 1] + g[i - 1][j - 1];
s2[i][j] = s2[i - 1][j + 1] + g[i - 1][j - 1];
}
set<int> S;
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= m; j ++ ) {
S.insert(g[i - 1][j - 1]);
for (int k = 1; i - k >= 1 && i + k <= n && j - k >= 1 && j + k <= m; k ++ ) {
int a = s2[i][j - k] - s2[i - k][j];
int b = s1[i][j + k] - s1[i - k][j];
int c = s2[i + k][j] - s2[i][j + k];
int d = s1[i + k][j] - s1[i][j - k];
S.insert(a + b + c + d - g[i + k - 1][j - 1] + g[i - k - 1][j - 1]);
}
while (S.size() > 3) S.erase(S.begin());
}
return vector<int>(S.rbegin(), S.rend());
}
};
给你两个整数数组 nums1 和 nums2 ，它们长度都为 n 。
两个数组的 异或值之和 为 (nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + … + (nums1[n - 1] XOR nums2[n - 1]) （下标从 0 开始）。
比方说，[1,2,3] 和 [3,2,1] 的 异或值之和 等于 (1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4 。
请你将 nums2 中的元素重新排列，使得 异或值之和 最小 。
请你返回重新排列之后的 异或值之和 。
示例 1：
输入：nums1 = [1,2], nums2 = [2,3]
输出：2
解释：将 nums2 重新排列得到 [3,2] 。
异或值之和为 (1 XOR 3) + (2 XOR 2) = 2 + 0 = 2 。
示例 2：
输入：nums1 = [1,0,3], nums2 = [5,3,4]
输出：8
解释：将 nums2 重新排列得到 [5,4,3] 。
异或值之和为 (1 XOR 5) + (0 XOR 4) + (3 XOR 3) = 4 + 4 + 0 = 8 。
提示：
n == nums1.length
n == nums2.length
1 <= n <= 14
0 <= nums1[i], nums2[i] <= 107
class Solution {
public:
typedef long long LL;
int minimumXORSum(vector<int>& nums1, vector<int>& nums2) {
LL minm=1e9;
sort(nums2.begin(),nums2.end());
do {
LL ans=0;
for(int i=0;i<nums1.size();i++)
{
ans+=(nums1[i]^nums2[i]);
}
minm=min(minm,ans);
} while (next_permutation(nums2.begin(), nums2.end()));
return minm;
}
};
上面这题的时间复杂度是O(n!)的,n是14，超时了。
那么接着，我们分析n最大为14，比较小，考虑状态压缩dp
我们用f[i]表示nums2数组里面每个数的状态，若对应位置为1表示这个数已经被用掉了，若这个数为0，表示这个数还没有被用，还可以用。
状态表示好了，下面考虑状态转移,数字i的二进制表示里面如果有s个1的话，表示b数组的前面s个位置已经被数字填充了，但是具体是被哪s个数字填充的是不知道的，我们枚举s个数字的最后一个数字是由被填充的数字中的哪一个来填充的，可以得到如下的状态转移方程.
f[i]=f[i-(1<<j)]+nums1[s-1]^nums2[j]
这样的时间复杂度由O(n!)变为o(2^n*n)
class Solution {
public:
int minimumXORSum(vector<int>& nums1, vector<int>& nums2) {
int maxn=1e9;
int n=nums1.size();
vector<int>f(1<<n,maxn);
f[0]=0;
for(int i=1;i<(1<<n);i++)
{
int s=0;
for(int j=0;j<n;j++)
{
if(i>>j&1)s++;
}
for(int j=0;j<n;j++)
{
if(i>>j&1)f[i]=min(f[i],f[i-(1<<j)]+(nums1[s-1]^nums2[j]));
}
}
return f[(1<<n)-1];
}
};
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
