第十三届蓝桥杯省赛C++B组
作者：互联网
刷题统计
思路：
考试的时候想都没想直接循环跑的暴力，然后结束一看数据范围大写的GG。正确做法是找规律推公式
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long a, b, n;
cin >> a >> b >> n;
long long res = 0;
res += 7 * (n / (5 * a + 2 * b));
n %= (5 * a + 2 * b);
long long d[] = {a,a,a,a,a,b,b};
for(int i = 0; n > 0; i ++ )
{
n -= d[i];
res ++ ;
}
cout << res << endl;
return 0;
}
X 进制减法
思路：
这题猜很好猜，就是a和b相对应的这一位最小的数+1就是这一位的进制。但考场上看了半天愣是没看出来321咋变成65的，也和进制不熟练有关系吧，这里算法是3是8进制2是10进制1是2进制，所以通俗想法就是1就是数多少个1变成1，这里就是1个，然后2要数多少个1变成2，因为最后一位是2进制，所以数两个1第二位变成1，再数两个1第二位变成2，所以一共是4个1。3也同理，因为最后一位是二进制，第二位是10进制，所以这一位数到1要数20个1，那么数到三就要数60个1，这样加起来就是65。
具体实现的时候我们可以定义一个k，从来表示当前这一位要数多少个1，即多少倍，然后每次k乘以当前这一位的数加到res上即可，注意因为是减法，所以要加上mod防止下溢出
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010, mod = 1000000007;
int n, ma, mb;
int a[N], b[N];
int c[N];
int main()
{
cin >> n >> ma;
for(int i = ma - 1; i >= 0; i -- ) cin >> a[i];
cin >> mb;
for(int i = mb - 1; i >= 0; i -- ) cin >> b[i];
for(int i = max(ma - 1, mb - 1); i >= 0; i -- )
c[i] = max(max(a[i], b[i]) + 1, 2);
LL res = 0;
LL k = 1;
for(int i = 0; i <= max(ma - 1, mb - 1); i ++ )
{
res = (res + k * (a[i] - b[i])) % mod;
res = (res + mod) % mod; // 有减法，需要此步骤防止变成负数
k = (k * c[i]) % mod;
}
cout << res << endl;
return 0;
}
统计子矩阵
思路：
满分做法不会，纯四重循环暴力拿大部分分
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int a[N][N], s[N][N];
int main()
{
int n, m, k;
cin >> n >> m >> k;
for(int i = 1; i <= n; i ++ )
for(int j = 1; j <= m; j ++ )
cin >> a[i][j], s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
int res = 0;
for(int x1 = 1; x1 <= n; x1 ++ )
for(int y1 = 1; y1 <= m; y1 ++ )
for(int x2 = x1; x2 <= n; x2 ++ )
for(int y2 = y1; y2 <= m; y2 ++ )
{
int sum = s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1];
if(sum <= k) res ++ ;
}
cout << res << endl;
return 0;
}
积木画
思路：
线性dp，我们设f[i][j]为把第i列填满，同时填了第i+1列j个方格的方案数，所以j一共有3种情况：0，1, 2。初始化时我们初始化f[1][0],f[1][1],f[1][2]，值分别为1 2 1。然后从2开始转移。
考虑f[i][0]：表示把第i列填满，同时没有填第i+1列的方案，可以想象到这种情况要么是第i-1列刚好填满，所以第i列只能填一个竖着的，方案数就是f[i-1][0]，要么是第i-1列填了两个横着的吧第i-1和第i列同时填完了，这种情况就是f[i-1][2]，即把第i-1列填满同时填满了第i列两个。
考虑f[i][1]：表示把第i列填满，同时填了第i+1列一个的方案，可以想象到这种情况要么是第i-1列刚好填满然后第i列填了一个L型，这种情况因为L有两种摆法，所以就是2*f[i-1][0]。要么是第i-1列填满同时填了第i列一个，这时候第i列就填一个横着的，因此是f[i-1][1]。
考虑f[i][2]：表示把第i列填满，同时又把第i+1列两个填满的方案。可以想象到这种情况要么是第i-1列刚好填满，所以第i列可以填两个横着的，就是f[i-1][0]，要么第i-1列填满同时还填了第i列一个，这时需要在第i列填一个L型来填满第i列的一个和第i+1列的两个，所以是f[i-1][1]
最终答案就是f[n][0]
#include <bits/stdc++.h>
using namespace std;
const int N = 10000010, mod = 1000000007;
int n;
long long f[N][3];
int main()
{
cin >> n;
f[1][0] = 1;
f[1][1] = 2;
f[1][2] = 1;
for(int i = 2; i <= n; i ++ )
{
f[i][0] = (f[i - 1][0] + f[i - 1][2]) % mod;
f[i][1] = (2 * f[i - 1][0] + f[i - 1][1]) % mod;
f[i][2] = (f[i - 1][0] + f[i - 1][1]) % mod;
}
cout << f[n][0] << endl;
return 0;
}
李白打酒加强版
思路：
闫氏dp分析法：f[i][j][k]表示当前走过了i家店，j朵花，当前还有k单位酒，属性是方法数count，因为我们最后刚好把酒喝完，因此我们一共喝了m次酒，因此k的取值是0到m，然后最后一步有两种走法，最后一步是店：就说明上一步是f[i - 1][j][k / 2]，这里当k为偶数才合法。然后还有最后一步是花：就说明上一步是f[i][j - 1][k +1]
最终答案要求的是最后一步是花同时把酒喝完的方案数，因此我们可以用倒数第二步的方案数来表示，就是f[n][m - 1][1]
#include <bits/stdc++.h>
using namespace std;
const int N = 110, mod = 1000000007;
int n, m;
int f[N][N][N];
int main()
{
cin >> n >> m;
f[0][0][2] = 1;
for(int i = 0; i <= n; i ++ )
for(int j = 0; j <= m; j ++ )
for(int k = 0; k <= m; k ++ )
{
if(i > 0 && k % 2 == 0) // 最后一步是店
f[i][j][k] = (f[i][j][k] + f[i - 1][j][k / 2]) % mod;
if(j > 0) // 最后一步是花
f[i][j][k] = (f[i][j][k] + f[i][j - 1][k + 1]) % mod;
}
// 最后一步是花并且酒刚好喝完，可以用倒数第二步的方案数
cout << f[n][m - 1][1] << endl;
return 0;
}
砍竹子
思路：
优先队列。我们按左端点排序，这样堆顶就是同一高度下左端点最大那个区间。
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 200010;
int n;
LL w[N];
struct seg{
int l, r;
LL h;
bool operator< (const seg& t) const{
if(h == t.h) return l < t.l;
return h < t.h;
}
};
LL solve(LL x)
{
return sqrt(x / 2 + 1);
}
int main()
{
cin >> n;
priority_queue<seg>heap;
for(int i = 1; i <= n; i ++ )
cin >> w[i];
for(int i = 1; i <= n; i ++ )
heap.push({i, i, w[i]});
int res = 0;
while(heap.top().h > 1)
{
auto a = heap.top();
heap.pop();
auto b = heap.top();
while(a.h == b.h && a.l - 1 <= b.r)
{
heap.pop();
a.l = b.l;
b = heap.top();
}
heap.push({a.l, a.r, solve(a.h)});
res ++ ;
}
cout << res << endl;
return 0;
}
标签：填满,const,int,LL,cin,long,蓝桥,C++,省赛 来源： https://www.cnblogs.com/yctql/p/16519371.html