LeetCode Weekly Contest 27

Reverse Words in a String III

简单暴力翻转

class Solution {
public:
string rev(string s)
{
int len=s.length();
int i=0,j=len-1;
while(i<j)
{
char temp=s[i];
s[i]=s[j];
s[j]=temp;
i++;
j--;
}
return s;
}
string reverseWords(string s) {
int len=s.length();
string ans="";
int j=0,i;
for(i=0;i<len;i++)
{
if(s[i]==' ')
{
string b=s.substr(j,i-j);
ans=ans+rev(b)+" ";
j=i+1;
}
}
string b=s.substr(j,i-j);
ans=ans+rev(b);
return ans;
}
};

　Brick Wall

使用map或者set存一下数据就能轻松ac

class Solution {
public:
int leastBricks(vector<vector<int> >& wall) {
map<int,int> st;
int len=wall.size();
int ans=0,mx=0;
for(int i=0;i<len;i++)
{
int wid=wall[i].size();
int sum=0;
for(int j=0;j<wid;j++)
sum+=wall[i][j];
if(sum>mx)
mx=sum;
}
for(int i=0;i<len;i++)
{
int wid=wall[i].size();
int sum=0;
for(int j=0;j<wid;j++)
{
sum+=wall[i][j];
st[sum]++;
if(st[sum]>ans&&sum!=mx)
ans=st[sum];
}
}
return len-ans;
}
};

　Next Greater Element III

给定一个32位整数n，您需要找到最小的32位整数，它与整数n中存在完全相同的数字，值大于n

贪心思路：从个位到高位，找到第一个逆序的位，和之前的大于它的最小数字交换，然后排序比它的低位所有数就行了

这样做保证正解的原因是我们确定了第一个可以变得更大的位，改变这个位后，这个位后面数字当然是越小越好

int cmp(int x,int y)
{
return x>y;
}
class Solution {
public:
int b[12],a[12];
int nextGreaterElement(int n) {
int idx=0;
int shit=n;
while(n>0)
{
a[idx++]=n%10;
n/=10;
}
memset(b,-1,sizeof(b));
b[a[0]]=0;
bool flag=true;
int ans=-1;
for(int i=1;i<idx;i++)
{
if(!flag)	break;
if(a[i]<a[i-1])
{
int j=a[i]+1;
while(j<10&&b[j]==-1)
j++;
if(j<=a[i-1])
{
flag=false;
//	cout<<j<<" "<<b[j]<<endl;
int temp=a[i];
a[i]=a[b[j]];
a[b[j]]=temp;
sort(a,a+i,cmp);
//	cout<<i<<endl;
}
}
b[a[i]]=i;
//	printf("%d\n",b[a[i]]);
}
int sum=0;
for(int i=idx-1;i>=0;i--)
{
sum=sum*10+a[i];
}
if(sum>ans&&sum>shit)
ans=sum;
return ans;
}
};

　Binary Tree Longest Consecutive Sequence II

找二叉树的最长连续序列

很简单的dfs，也可以说的简单树规吧。思路是每的结点的最长序列是：

1+左子树递增最长+右子树递减最长 或者 1+左子树递增最长+右子树递减最长啦，我们的返回值存这两个东西就ok

class Solution {
public:
struct fuck{
int x,y;
};
int ass;
int fb(int x)
{
if(x>0)	return x;
return -x;
}
fuck dfs(TreeNode* root)
{
if(root==NULL)
{
fuck ans;
ans.x=0;ans.y=0;
return ans;
}
fuck a=dfs(root->left);
fuck b=dfs(root->right);
fuck ans;
ans.x=1;ans.y=1;
int mx,my;
mx=my=0;
if(root->left!=NULL)
{
int aa=root->left->val;
if(root->val-aa==1)
mx=max(mx,a.x);
else if(aa-root->val==1)
my=max(my,a.y);
}
if(root->right!=NULL)
{
int bb=root->right->val;
if(root->val-bb==1)
mx=max(mx,b.x);
else if(bb-root->val==1)
my=max(my,b.y);
}
ans.x+=mx;
ans.y+=my;
if(ans.x+ans.y-1>ass)
ass=ans.x+ans.y-1;
return ans;
}
int longestConsecutive(TreeNode* root) {
ass=0;
dfs(root);
return ass;
}
};