8.29-9.4 OJ做题笔记

Tokitsukaze and Meeting（1700）

题意：给定n*m的网格。学生从第一行(1,1)开始进入，每来一个学生改行学生往后右移一个位置，该行最后一个位置学生进入下一行第一个，以此类推。每个学生有个标志0和1.求第i个学生进入后，至少一行有学生1和至少一列有学生1的行列个数总和。
题解：
对列，使用队列模拟。
对行，可以增量更新。第二行到最后的情况可以由前面已求过dp[j-m]的推出，只需考察第一行的情况即可。（子问题）

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;


int main()
{
	int t; cin>>t;
	for(int i = 0;i<t;i++)
	{
		int n,m; cin>>n>>m;
		string s;cin >> s;
		queue<int> q;
		int dp[n*m],dpcol[n*m],ans[n*m];
		int row1count = 0;
		int col1count = 0;
		for(int j = 0;j<m;j++) {
			q.push(s[j] - '0');
			if(s[j]=='1') {
				row1count++; col1count++;
			}
			dp[j]=row1count>0;
			ans[j]=dp[j]+col1count;
		}
		for(int j = m;j<n*m;j++)
		{
			//update the row
			row1count = row1count + (s[j] - '0') -  (s[j - m] - '0');
			dp[j] = dp[j - m] + (row1count > 0);
			//update the coloum 
			col1count -= q.front();
			int a  =  q.front() || (s[j] - '0');
			col1count += a;
			q.pop();
			q.push(a);
			ans[j] = col1count + dp[j];
		}
		for(int j = 0;j<n*m;j++)cout<<ans[j]<<" ";cout<<endl;
	}
	system("pause");
	return 0;
}

反思：可以考虑多个时间步长的增量关系，不要仅限于相邻步长的增量关系。多考虑是否有可以利用的子问题。

参加考试的最大学生数(leetcode)

题意：

题解：设dp[i][k]处理到第i排且第i排安排座位情况为k时。暴力枚举每一排状压的k值即可。

class Solution {
public:
    int n;
    int m;
    bool j1(int cur,int pre)  //按上一行的情况是否可行
    {
        for(int k = n - 1;k>=0;k--)
        {
            if(((cur>>k)&1) == 1)
            {
                if(k-1>=0&&((pre>>(k-1))&1)==1) return false;
                if(((pre>>(k+1))&1)==1) return false;
            }
        }
        return true;
    }
    bool j2(int cur,vector<char>& now) //按本行的情况是否可行
    {
        for(int k = n - 1;k>=0;k--)
            if((((cur >> k) & 1) && ((cur >> (k+1)) & 1))||now[n - 1 - k] == '#' && ((cur >> k) & 1) == 1) return false;return true;
    }
    int count1(int cur)
    {
        int ans = 0;
        for(int  k = n- 1;k>=0;k--) if(((cur >> k) & 1) == 1) ans++;return ans;
    }
    int maxStudents(vector<vector<char>>& seats) {
        m = seats.size();  n = seats[0].size();
        int dp[m][(1 << n)];
        for(int i =0;i<m;i++) memset(dp[i],-1,sizeof(dp[i]));
        for(int i = 0;i<1<<n;i++)
        {
            if(j2(i,seats[m-1])) dp[m-1][i]=count1(i);
        }
        for(int i = m - 2;i>=0;i--)
        {
            for(int p  = 0;p<1<<n;p++)
            {
                if(!j2(p,seats[i]))continue;
                int c = count1(p);
                for(int q = 0;q<1<<n;q++)
                {
                    if(dp[i+1][q]!=-1 && j1(p,q))
                    {
                        dp[i][p]=max(dp[i][p],c+dp[i+1][q]);
                    }
                }
            }
        }
        int ans = 0;
        for(int i = 0 ;i<1<<n;i++) ans = max(ans,dp[0][i]);return ans;
    }
};

反思：现在连这种基础的dp都想不到了。注意状态间的转换关系。第i排仅和i-1排的情形有关，进而简化dp。（只和前面一个状态有关）

leetcode-超级洗衣机（Very GOOD）

****

题解：最大时间为所有洗衣机最大发送衣服的数量，这是因为所有洗衣机衣服的发送都可以并行进行。对于洗衣机$i$,讨论其发送衣服的情况即可。

class Solution {
public:
typedef long long ll;
    int findMinMoves(vector<int>& machines) {
        ll s = 0;
        for(int v : machines) s+=(ll)v;
        if(s%machines.size()!=0) return -1;
        ll each = s/machines.size();
        int pre  = 0;int ans = 0;
        int avg = s/machines.size();
        for(int i = 0;i<machines.size();i++)
        {
            int now = machines[i] - avg;
            int back = 0 - pre - now;
            
            if(pre<0&&back<0)
            {
                ans=max(ans,now);
            }
            else if(pre<0&&back>0)
            {
                ans=max(ans,back+now);
            }
            else if(pre>0&&back<0)
            {
                ans=max(ans,pre+now);
            }
            else if(pre==0||back==0)
            {
                if(now>0) ans=max(ans,now);
            }
            pre+=now;
        }
        return ans;
    }
};

反思：这道题当时没做出来，洗衣机之间可以并行运行，一台洗衣机发送一件衣服一定需要一个单位的时间，是该题一大关键。在整体考虑走投无路时，考虑枚举或局部。

按列翻转得到最大值等行数(leetcode-medium)

题意：
返回行中所有值都相等的最大行数。

题解:划分解空间：固定某一行，将其变为全1或全0.则当且仅当与该行字符完全相同或截然相反的行满足题目条件。可以暴力遍历，也可以进行聚类。同时，该题值得学习的地方有使用哈希表作为字符串映射加速。

class Solution {
public:
    int maxEqualRowsAfterFlips(vector<vector<int>>& matrix) {
        int m = matrix.size(); int n = matrix[0].size();
        int res = 0;
        map<string,int> a;
		for(int i = 0;i<m;i++)
        {   
            string s;
            for(int j = 0;j<n;j++) s+=(matrix[i][j] + '0');
            a[s]++;
        }
        int ans = 0;
        for(int i = 0;i<m;i++)
        {
        	string a1; string a2;
        	string s;
            for(int j = 0;j<n;j++) s+=(matrix[i][j] + '0');
			string s2;
			for(int j =0 ;j<n;j++) s2+=(!matrix[i][j] + '0');
			ans = max(ans,a[s]+a[s2]);
		}
        return ans;
    }
};

戳气球(重点复习)

题解：这种自顶向下的$DP$题在石子合并题那又卡了一次qwq。要避免DP增量更新为1的思维定势。
逆向思维：brute force地枚举最后一个被戳破的气球k.
将问题$dp[1][n]$分解为$dp[1][k-1]$和$dp[k+1][n]$
递归方程：
d p [ 1 ] [ n ] = m a x k { d p [ 1 ] [ k − 1 ] + d p [ k + 1 ] [ n ] + 1 ⋅ 1 ⋅ n u m s [ k ] } dp[1][n] = max_k \{ dp[1][k-1]+dp[k+1][n] + 1 \cdot 1 \cdot nums[k] \} dp[1][n]=maxk​{dp[1][k−1]+dp[k+1][n]+1⋅1⋅nums[k]}
实际上$dp[i][j]$的含义是将$i-1,j+1$都存在的情况下，戳破nums[i]…nums[j]所有气球能获得的最大钱数。

class Solution {
public:
    int maxCoins(vector<int>& nums) {
        nums.insert(nums.begin(),1);
        nums.push_back(1);
        int n = nums.size() - 2;
        int dp[n+1][n+1];
        for(int i = 1;i<=n;i++) dp[i][i] = nums[i+1] * nums[i-1] * nums[i];
        for(int i = n;i>=1;i--)
        {
            for(int j = i + 1;j<=n;j++)
            {
                dp[i][j] = nums[i-1]*nums[i]*nums[j+1]+dp[i+1][j];
                for(int k = i + 1;k<=j - 1;k++)
                {
                    dp[i][j] = max(nums[i - 1]*nums[k]*nums[j+1]+dp[i][k-1]+dp[k+1][j],dp[i][j]);
                }
                dp[i][j] = max(dp[i][j],nums[i-1]*nums[j]*nums[j+1]+dp[i][j-1]);
            }
        }
        return dp[1][n];
    }
};

反思：这道题和石子合并很类似。都是枚举最后一次的结果然后DP。