代码源每日一题 div1 (701-707)

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量1.6k 收藏 1
点赞数 1
分类专栏： 代码源每日一题 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a12377978/article/details/124343209
版权

代码源每日一题 div1 (701-707)

画画

[Link](画画 - 题目 - Daimayuan Online Judge)

思路

  • 倒序模拟

    发现我们一定有一些操作涂抹了某个正方形后其它的操作不会再碰这个正方形了（最起码最后一步涂的正方形一定是这样的）。

    因此我们可以考虑倒着考虑，找到上面说的那些操作的块，将他们涂上，然后打个标记，接下来这些打标记的涂什么都可以，因为最后会被上一次的操作覆盖掉，所以如果有解，就可以不断的打标机，将整个图覆盖，最后方案就是将我们记录的倒过来即可。

    如果发现某个点没打标记，就代表无解了。

附一个原题链接，代码源上过不了。

[Link](Problem - D - Codeforces)

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1010, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int g[N][N];
vector<array<int, 3>> res;

void dfs(int x, int y) {
    if (x < 1 || x > n - 1 || y < 1 || y > m - 1) return ;
    
    int tag = 0;
    for (int i = x; i <= x + 1; i ++)
        for (int j = y; j <= y + 1; j ++)
            if (g[i][j]) {
                if (tag && tag != g[i][j]) return ;
                else if (!tag) tag = g[i][j];
            }

    if (tag) {
        res.push_back({x, y, tag});
        for (int i = x; i <= x + 1; i ++)
            for (int j = y; j <= y + 1; j ++)
                g[i][j] = 0;
        for (int i = x - 1; i <= x + 1; i ++) 
            for (int j = y - 1; j <= y + 1; j ++)  
                dfs(i, j);
    }
}
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= m; j ++)
            cin >> g[i][j];

    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= m; j ++)
            if (g[i][j])
                dfs(i, j);
    
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= m; j ++)
            if (g[i][j]) {
                cout << -1 << '\n';
                return 0;
            }
    
    reverse(res.begin(), res.end());
    cout << res.size() << '\n';
    for (auto t : res)
        cout << t[0] << ' ' << t[1] << ' ' << t[2] << '\n';
    return 0;
}

数字替换

[Link](数字替换 - 题目 - Daimayuan Online Judge)

思路

  • 并查集维护

如果每次从头到尾遍历修改复杂度太高。因为是对于一个相同数的操作，也就是对于集合的操作，我们可以用并查集来维护（选取集合代表元素），记录每个位置是什么数，每个数在哪个位置，即可。

对于一个新加的数，如果前面出现过就直接将其合并到前面，否则就初始化这个数在的位置。

对于要修改的 x x x变 y y y，如果 y y y出现过直接将 x x x的代表元素合并到 y y y上，将 x x x置为不存在，如果 y y y没出现过那就将 y y y置为 x x x的位置，将 x x x位置的数改为 y y y，置 x x x不存在即可。

Code

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <set>
#include <queue>
#include <vector>
#include <map>
#include <bitset>
#include <unordered_map>
#include <cmath> 
#include <stack>
#include <iomanip>
#include <deque> 
#include <sstream>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 5e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
#define tpyeinput int
inline char nc() {static char buf[1000000],*p1=buf,*p2=buf;return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;}
inline void read(tpyeinput &sum) {char ch=nc();sum=0;while(!(ch>='0'&&ch<='9')) ch=nc();while(ch>='0'&&ch<='9') sum=(sum<<3)+(sum<<1)+(ch-48),ch=nc();}
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
	e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N];
int f[N], vis[N], num[N];
int find(int x) {
	return x == f[x] ? x : f[x] = find(f[x]);
}
int main() {
	ios::sync_with_stdio(false), cin.tie(0);
	int T; cin >> T;
	for (int i = 1; i <= T; i ++) {
		int op; cin >> op;
		if (op == 1) {
			int x; cin >> x;
			a[++n] = i, f[i] = i, vis[i] = x;
			if (num[x]) 				f[i] = num[x];			
			else num[x] = i;
		}
		else {
			int x, y; cin >> x >> y;
			if (x != y && num[x]) {
				if (num[y]) {
				f[num[x]] = num[y];
				num[x] = 0;
			}
			else {
				num[y] = num[x];
				vis[num[x]] = y;
				num[x] = 0;
			}
			}
		}
	}
	for (int i = 1; i <= n; i ++) cout << vis[find(a[i])] << ' ';
	cout << endl;
	return 0;
}
  • 倒序模拟

因为每个数可能会变多次，所以我们倒着来模拟， f [ y ] : y 变 成 什 么 f[y]:y变成什么 f[y]:y变成什么，对于插入操作如果 f [ x ] ! = 0 f[x]!=0 f[x]!=0我们直接插入 f [ x ] f[x] f[x]即可，对于改变操作，如果 f [ y ] = = 0 f[y]==0 f[y]==0代表后面 y y y不会改变， f [ x ] = y f[x]=y f[x]=y即可，如果 f [ y ] ! = 0 f[y]!=0 f[y]!=0代表后面 f [ y ] f[y] f[y]变了 f [ x ] = f [ y ] f[x]=f[y] f[x]=f[y]即可（当前操作被后面影响了），也有点路径压缩的感觉，最后正序输出即可。

Code

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <set>
#include <queue>
#include <vector>
#include <map>
#include <bitset>
#include <unordered_map>
#include <cmath> 
#include <stack>
#include <iomanip>
#include <deque> 
#include <sstream>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 5e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
#define tpyeinput int
inline char nc() {static char buf[1000000],*p1=buf,*p2=buf;return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;}
inline void read(tpyeinput &sum) {char ch=nc();sum=0;while(!(ch>='0'&&ch<='9')) ch=nc();while(ch>='0'&&ch<='9') sum=(sum<<3)+(sum<<1)+(ch-48),ch=nc();}
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
	e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N][3];
vector<int> ve;
int f[N];
int main() {
	ios::sync_with_stdio(false), cin.tie(0);
	cin >> n;
	for (int i = 1; i <= n; i ++) {
		cin >> a[i][0];
		if (a[i][0] == 1) cin >> a[i][1];
		else cin >> a[i][1] >> a[i][2];
	}

	for (int i = n; i; i --) {
		if (a[i][0] == 1) {
			if (!f[a[i][1]]) ve.push_back(a[i][1]);
			else ve.push_back(f[a[i][1]]);
		}
		else {
			if (!f[a[i][2]]) f[a[i][1]] = a[i][2];
			else 		     f[a[i][1]] = f[a[i][2]];
		}
	} 
	
	reverse(ve.begin(), ve.end());
	for (auto x : ve) cout << x << ' ';
	cout << endl;
	return 0;
}

游戏

[Link](游戏 - 题目 - Daimayuan Online Judge)

思路

  • 博弈

    首先如果 n , m n,m n,m均小于 2 k 2k 2k则第一个人放中间一定必胜，否则的话 n , m n,m n,m均为奇数第一个人胜，剩下第一个人败。

    具体证明不懂，抽时间再看。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    cin >> n >> m >> k;
    if (n < 2 * k && m < 2 * k) cout << "Alice\n";
    else {
        if (n & 1 && m & 1) cout << "Alice\n";
        else cout << "Bob\n";
    }
    return 0;
}

合适数对（数据加强版）

[Link](合适数对（数据加强版） - 题目 - Daimayuan Online Judge)

思路

  • 分解质因数

​ 将每个数分解质因数会称为 x 1 p 1 x 2 p 2 . . . x k p k x_1^{p_1}x_2^{p^2}...x_k^{p_k} x1p1​​x2p2​...xkpk​​，我们如果让两个数 a l × a r = x k a_l\times a_r=x^k al​×ar​=xk，那么他们的每一个质因子的次幂一定是 k k k的倍数，因此先将次幂 m o d   k mod\ k mod k，大于 k k k的部分没有用。

​ 因此我们从前往后遍历对于 i i i我们找到它的每个质因子次幂关于 k k k的补数，将它要查的对应的数找到，判断这个数是否存在。

​ 将每个是分解质因子，朴素的做法是$\sqrt n $的，我们可在筛质数的时候顺便求出每个数的质因子，用空间换一下时间，再优化一下常数不考虑 2 2 2的倍数，这样会快很多。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e6 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int primes[N * 10], cnt;
bool st[N * 10];
int mn[N * 10];
void get(int x) {
    primes[cnt ++] = 2;
    mn[2] = 2;
    for (int i = 3; i <= x; i += 2) {
        if (!st[i]) primes[cnt ++] = i, mn[i] = i;
        for (int j = 0; primes[j] <= x / i; j ++) {
            st[primes[j] * i] = true;
            mn[primes[j] * i] = primes[j];
            if (i % primes[j] == 0) break;
        }   
    }
}
LL qmi(LL a, LL b) {
    LL res = 1;
    while (b) {
        if (b & 1) res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}
int mp[N * 10];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    get(10000000);
    cin >> n >> k;
    LL res = 0;
    for (int i = 1; i <= n; i ++) {
        int x; cin >> x;
        LL p = 1, q = 1;
        while (x != 1) {
            int t = x % 2 ? mn[x] : 2;
            int cnt = 0;
            while (x % t == 0) {
                cnt ++, cnt %= k;
                x /= t;
            }      
            p *= qmi(t, cnt);
            if (cnt) q *= qmi(t, k - cnt);
            if (q < 0 || q > 10000000) q = 0;
        }
    
        res += mp[q];
        mp[p] ++;
    }

    cout << res << '\n';
    return 0;
}

Fence Painting

[Link](Fence Painting - 题目 - Daimayuan Online Judge)

思路

  • 模拟，贪心

​ 首先处理出来所有染色不对的块，倒来看每个画家，如果当前这个画家要涂的色存在不对的我们直接涂到对应位置，如果不存在我们判断一下这个颜色是否本来就是对的或者是否前面有某个颜色涂到了对应的位置，我们直接将它涂到那个位置即可，这样后面这个位置的操作就会将其覆盖掉。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N], c[N], b[N], res[N];
stack<int> q[N];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int T;
    cin >> T;
    while (T -- ) {
        cin >> n >> m;
        map<int, int> mp;
        int cnt = 0;
        bool ok = true;
        for (int i = 1; i <= n; i ++) cin >> a[i];
        for (int i = 1; i <= n; i ++) {
            cin >> b[i];
            if (b[i] != a[i]) {
                ok = false;
                cnt ++;
                q[b[i]].push(i);
            }
            else mp[a[i]] = i;
        }
        for (int i = 1; i <= m; i ++) cin >> c[i];

        if (ok) {
            ok = false;
            int pos = 0;
            for (int i = 1; i <= n; i ++)
                if (a[i] == c[m]) {
                    ok = true;
                    pos = i;
                    break;
                }
            if (ok) {
                cout << "YES\n";
                for (int i = 1; i <= m; i ++)
                    cout << pos << ' ';
                cout << '\n';
            }
            else cout << "NO\n";
        }
        else {
            ok = true;
            int pre = -1;
            for (int i = m; i; i --) {
                if (mp.find(c[i]) == mp.end() && !q[c[i]].size() && pre == -1) {
                    ok = false;
                    break;
                }
                else {
                    if (pre == -1 && !q[c[i]].size()) pre = mp[c[i]];
                    if (!q[c[i]].size()) res[i] = pre;
                    else {
                        auto t = q[c[i]].top();
                        if (q[c[i]].size()) q[c[i]].pop(), cnt --;
                        res[i] = t;
                        pre = t; 
                    }
                }
            }
            for (int i = 1; i <= n; i ++)
                while (q[b[i]].size()) q[b[i]].pop();

            if (cnt > 0) cout << "NO\n";
            else {
                cout << "YES\n";
                for (int i = 1; i <= m; i ++)
                    cout << res[i] << ' ';
                cout << '\n';
            }
            }
        
    }
    return 0;
}

质数区间

Link

思路

  • 前缀和，二分

​ 求最小长度，很显然如果长度为 l e n len len符合，那么 l e n + 1 len+1 len+1一定也符合，因此直接二分答案，判断当前答案是否成立即可，判断答案就直接枚举每个起点判断当前起点往后的这个区间是否有 ≥ k \ge k ≥k个质数即可。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e6 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int primes[N], cnt;
bool st[N];
void get(int x) {
    st[1] = true;
    for (int i = 2; i <= x; i ++) {
        if (!st[i]) primes[cnt ++] = i;
        for (int j = 0; primes[j] <= x / i; j ++) {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}
int tr[N];
void add(int x) {
    for (; x <= 1000000; x += (x & -x)) tr[x] ++;
}
int sum(int x) {
    int res = 0;
    for (; x; x -= (x & -x)) res += tr[x];
    return res;
}
int L, R; 
bool check(int len) {
    for (int i = L; i + len - 1 <= R; i ++)
        if (sum(i + len - 1) - sum(i - 1) < k) 
            return false;
    return true;
} 
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    get(1000000);
    cin >> L >> R >> k;
    for (int i = L; i <= R; i ++)
        if (!st[i])
            add(i);

    int l = 1, r = R - L + 1;
    if (sum(R) - sum(L - 1) < k) {
        cout << -1 << '\n';
        return 0;
    }     
    while (l < r) {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;
        else l = mid + 1; 
    }
    cout << r << '\n';
    return 0;
}

最长有趣子序列

[Link](最长有趣子序列 - 题目 - Daimayuan Online Judge)

思路

  • d p dp dp

​ 求最长什么子序列，我们仿照最长上升子序列的做法，设 f [ i ] : 以 a i 结 尾 的 最 长 有 趣 子 序 列 f[i]:以a_i结尾的最长有趣子序列 f[i]:以ai​结尾的最长有趣子序列，唯一不同的就是转移的条件不同，暴力的想法是我们从前面所有 a i & a j ! = 0 a_i\&a_j!=0 ai​&aj​!=0的点转移过来，这样是 O ( n 2 ) O(n^2) O(n2)的复杂度，换一个角度，我们可以转移过来的位置一定是二进制和当前这个点的二进制有某一位都是 1 1 1，因此我们可以直接枚举从二进制的哪一位转移过来，对于某一位我们只需要记录这一位有的最长有趣系序列即可，这样复杂度就降下来了。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e6 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N];
int f[N], bit[31];
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> a[i];
    int res = 0;
    for (int i = 1; i <= n; i ++) {
        for (int j = 0; j <= 30; j ++)
            if (a[i] >> j & 1) 
                f[i] = max(f[i], bit[j] + 1);
        res = max(res, f[i]);

        for (int j = 0; j <= 30; j ++)
            if (a[i] >> j & 1)
               bit[j] = max(bit[j], f[i]); 
    }        
    cout << res << '\n';
    return 0;
}
枉玊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设置div的z-index属性让div在另外一个div之上
01-21
怎么让一个div在另外一个div之上呢，这是建站最常见的一个问题，例如 做一个客服窗口让他左飘，然而其他的div就会挡住客服窗口（在小屏幕情况下） 就可以设置div的z-index属性，让div永远在上。这样就OK啦 复制...
通过js获取div的background-image属性
01-21
之前没有注意过div的background-image这个属性，只是设置它的url，今天遇到一个问题特此做一下记录。 代码如下: <div id=”img_2″ xss=removed xss=removed></div> 在js中想获取image属性 代码如下: document....
代码源div1
Destiny
10-05 593
训练题目集
代码源每日一题 div1 #804 石子游戏 II
灯灯登登的博客
04-28 1097
#804 石子游戏 II 思路 对于博弈论问题，应该考虑以下几个问题： 什么局面不能操作（失败态） 每种操作会对当前状态发生什么样的改变 如果表示当前这个局面 先考虑不能操作的局面，为： k个1，以及一个偶数。(k>=0)(k>=0)(k>=0) k个1。 (k>=0)(k>=0)(k>=0) 基于此，所以我们可以把当前局面表示为：1的个数和偶数的个数。 再考虑每种操作会对当前局面发生的变化。那么： 拆分一堆奇数的石子。即让偶数个数+1 合并两堆偶数的石子，即让
代码源每日一题 div1 （401-407）
a12377978的博客
04-21 609
代码源每日一题 div1 （401-407） 蜗蜗的数列 [Link](蜗蜗的数列 - 题目 - Daimayuan Online Judge) 思路 差分 ​ 首先ci=ai−bic_i=a_i-b_ici​=ai​−bi​，等价于让我们求操作后cic_ici​均为零。对于区间操作我们倾向于改变成单点操作，这样复杂度就降下来了，观察斐波那契数列fi=fi−1+fi−2f_i=f_{i-1}+f_{i-2}fi​=fi−1​+fi−2​，每一项与前两项有关，我们设di=ci−ci−1−ci−2d_i=c
代码源每日一题 div1 （601-607）
a12377978的博客
04-21 480
代码源每日一题 div1 （601-607） 并行排序 [Link](并行排序 - 题目 - Daimayuan Online Judge) 思路 最长下降子序列 ​ 前面的数大于后面的数就会连一条边，我们可以把最长下降子序列搞出来假设长为lenlenlen，因为是递减的，子序列中每一个点都需要和前面的不同也需要和后面的不同，因此长为几就需要上多少个色，因为其他的下降子序列比最长下降子序列短，所以需要更少的颜色就可以将其涂抹掉，所以解就是最长下降子序列的长度。 Code #include <bit
代码源每日一题Div.1 (401-407)
xhyu61的博客
06-30 556
我可是有朋友的。还有三个。 ——《青春猪头少年系列》梓川咲太
clk_div.rar_clk div_clk_div源代码
09-19
本文将通过分析标题为“clk_div.rar_clk div_clk_div源代码”的压缩包内容，深入探讨分频计数器的设计原理及其Verilog实现。 分频计数器，顾名思义，是一种能够将输入时钟频率降低的数字电路。在电子系统中，我们...
clk_div2.rar_clk_div源代码_div2
09-24
【标题】"clk_div2.rar_clk_div源代码_div2"涉及的是数字逻辑设计中的一个常见模块——分频器。在 FPGA（Field-Programmable Gate Array）或 CPLD（Complex Programmable Logic Device）的设计中，分频器是基础且...
非常不错的弹出一个div的js代码
12-01
LIGHTBOX EXAMPLE .black_overlay{ display: none; position: absolute; top: 0%; left: 0%; width: 100%; height: 100%; background-color: black; z-index:1001; -moz-opacity: 0.8; opacity:.80;...
代码源每日一题Div1 108数数
qq_45769627的博客
03-03 356
题目链接 思路 我们用树状数组维护区间和，将数组 aaa 带着下标，按照值大小从小到大排序，再将每个询问，按照 hhh 值从小到达排序。然后我们遍历每个询问，对于当前的 hhh ，将数组 aaa 中小于等于的 hhh的数的下标 pospospos 进行，add(pos,1)add(pos,1)add(pos,1)。这个询问的答案就是 ask(ri)−ask(li−1)。ask(r_i) - ask(l_i-1)。ask(ri​)−ask(li​−1)。 代码 #include<bits/stdc++.
代码源每日一题div1 最大权值划分
qq_53287227的博客
04-07 424
Daimayuan Online Judge 思路：dpdpdp 首先我们考虑对于某个序列的其中一段例如：[7,5,4,6][7,5,4,6][7,5,4,6]这一段拆分成：[7,5,4][6][7,5,4][6][7,5,4][6]两段，那么这两种情况对于前一段的结果是不会发生变化的，那么我们放到整个序列中，其每段都一定保证着单调 但满足这一条件下，一定满足权值和最大吗？显然我们可以举出反例：[1,2,3,4][1][1,2,3,4][1][1,2,3,4][1]不如：[1,2,3][4,1][1,2,3
树的先序，中序，后序遍历
远行的博客
08-03 672
先序输出:根左右（左子树，右子树） A B D G H E C K F I J 中序输出:（左根右） G D H B E A K C I J F 后序输出:（左右根） G H D E B K J I F C A 先序：ABC 中序：CBA 元素全在树的左边，先序和中序顺序相反 先序：ABC 中序：ABC 元素全在树的右边，先序和中序顺序相同 对于后序遍历而言，树的第一个根节点总是最后输出的 ...
合适数对---树状数组+二分
ZZU_LGY
03-20 222
题目链接 #include <iostream> #include <cstring> #include <algorithm> #include <vector> using namespace std; #define int long long const int N = 400010; int s[N]; int tr[N]; int n,m; vector<int>nums; int lowbit(int x) { return.
#555 整齐的数组2
qq_28409093的博客
03-18 329
#include<bits/stdc++.h> using namespace std; #define rep(i,l,r) for(int i=(l);i<=(r);i++) #define per(i,l,r) for(int i=(l);i>=(r);i--) #define ll long long #define mset(s,t) memset(s,t,sizeof(t)) #define mcpy(s,t) memcpy(s,t,sizeof(t)) #define
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 881
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 183
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 329
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 265
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
解释代码：div.line-around
05-03
`div.line-around` 是一个 CSS 选择器，它表示选择所有 `<div>` 标签中 `class` 属性值为 `line-around` 的元素。这个选择器通常用于添加一个带有边框的分割线，可以通过 CSS 样式来控制边框的颜色、粗细、样式等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值