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;
    }
};