Codeforces Round 867 (Div. 3) （E-G）

news2024/9/20 14:58:30

Problem - E - Codeforces

        （1）题目大意        

                给你一个字符串，问你让字符串每一对相对应位置都不同的最小操作数是多少？（A[i]和A[n - i],A[i + 1]和A[n - i - 1]）

         （2）解题思路

                1.首先字符串为奇数一定不可以

                2.其次如果字符串中某个字母的个数>n/2，则也不可以

                3.答案的构成，不会证明。

                考虑主元素法，答案要么就是最大的相同对的字母或者是总共的相同对的总数/2，这两个取个max就行了。

         （3）代码实现

#include<bits/stdc++.h>
#define sz(x) (int) x.size()
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 5e5 + 10;

void solve(){
	int n;
	cin >> n;
	string s;
	cin >> s;
	vector <int> cnt(26);
	if(n & 1) {
		cout << -1 << endl;
		return;
	}
	for(auto x : s) cnt[x - 'a'] ++;
	int mx = 0;
	for(int i = 0;i < 26;i ++) {
		if(cnt[i] > n / 2) {
			cout << -1 << endl;
			return;
		}
	}
	int l = 0,r = n - 1,ans = 0;
	for(int i = 0;i < 26;i ++) cnt[i] = 0;
	while(l < r) {
		if(s[l] == s[r]) cnt[s[l] - 'a'] ++,ans ++;
		l ++,r --;
	}
	for(int i = 0;i < 26;i ++) mx = max(mx,cnt[i]);
	cout << max((ans + 1) / 2,mx) << endl;
}

int main()
{
    ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T = 1;
	cin >> T;
	while(T --) solve();
}

Problem - F - Codeforces

        （1）题目大意

         （2）解题思路

                考虑找到最长的那条链，做两次dfs即可，或者考虑换根dp，我的做法是两次dfs，首先从1跑一遍dfs记录一下深度，然后从最远的那个点再跑一次dfs即可。

                记第一次dfs处理的数组为dp1，第二次的数组为dp2，则有两种情况

                        1.需要进行操作：ans = max(ans,dp2[i] * k - dp1[i] * c);

                        2.不需要进行操作： ans = max(ans,dp1[i]*k);

         （3）代码实现

#include<bits/stdc++.h>
#define sz(x) (int) x.size()
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
const int N = 3e5 + 10;
vector <int> g[N];
int dp1[N],dp2[N];
void dfs1(int u,int f)
{
	for(auto v : g[u]) {
		if(v == f) continue;
		dp1[v] = dp1[u] + 1;
		dfs1(v,u);
	}
}

void dfs2(int u,int f)
{
	for(auto v : g[u]) {
		if(v == f) continue;
		dp2[v] = dp2[u] + 1;
		dfs2(v,u);
	}
}
void solve(){
	int n,k,c;
	cin >> n >> k >> c;
	for(int i = 1;i <= n;i ++) g[i].clear();
	for(int i = 1;i <= n - 1;i ++) {
		int u,v;
		cin >> u >> v;
		g[u].pb(v),g[v].pb(u);
	}
	dp1[1] = 0;
	dfs1(1,0);
	int rt = 1;
	for(int i = 1;i <= n;i ++) {
		if(dp1[i] > dp1[rt]) 
			rt = i;
	}
	dp2[rt] = 0;
	dfs2(rt,0);
	ll ans = 0;
	for(int i = 1;i <= n;i ++) {
		ans = max(ans,1ll * dp1[i] * k);
		ans = max(ans,1ll * dp2[i] * k - 1ll * dp1[i] * c);
	}
	cout << ans << endl;
}

int main()
{
    ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T = 1;
	cin >> T;
	while(T --) solve();
}

Problem - G2 - Codeforces

        （1）题目大意

                给你一个长度为n的序列，让你找到i，j，k的对数，满足a[j] = b * a[i],a[k] = b * a[j]。

         （2）解题思路

                G1我们直接枚举暴力即可，但是G2发现a[i]有1e9，因此我们考虑使用PollardRho暴力分解质因子，然后根据质数平方因子处理出两个数组出来，再根据这些因子计算答案即可。

         （3）代码实现

#include "bits/stdc++.h"
#include <cstdint>
#include <functional>
#include <random>
#include <cmath>
#include <cstdint>
#include <functional>
#include <memory>
#include <cassert>
#include <cstdint>
#include <functional>
#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cstdint>
#include <initializer_list>
#define sz(x) (int) x.size()
#define rep(i,z,n) for(int i = z;i <= n; i++)
#define per(i,n,z) for(int i = n;i >= z; i--)
#define PII pair<int,int>
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
const int N = 1e6 + 10;
int a[N];
namespace OY {
    template <typename _ModType>
    struct Barrett {
        _ModType m_P;
        __uint128_t m_Pinv;
        constexpr Barrett() = default;
        constexpr explicit Barrett(_ModType __P) : m_P(__P), m_Pinv(-uint64_t(__P) / __P + 1) {}
        constexpr _ModType mod() const { return m_P; }
        constexpr _ModType mod(uint64_t __a) const {
            __a -= uint64_t(m_Pinv * __a >> 64) * m_P + m_P;
            if (__a >= m_P) __a += m_P;
            return __a;
        }
        constexpr _ModType multiply(uint64_t __a, uint64_t __b) const {
            if constexpr (std::is_same_v<_ModType, uint64_t>)
                return multiply_ld(__a, __b);
            else
                return multiply_64(__a, __b);
        }
        constexpr _ModType multiply_64(uint64_t __a, uint64_t __b) const {
            // assert(__a * __b < 1ull << 64);
            return mod(__a * __b);
        }
        constexpr _ModType multiply_128(uint64_t __a, uint64_t __b) const {
            if (__builtin_clzll(__a) + __builtin_clzll(__b) >= 64) return multiply_64(__a, __b);
            return __uint128_t(__a) * __b % m_P;
        }
        constexpr _ModType multiply_ld(uint64_t __a, uint64_t __b) const {
            // assert(m_P < 1ull << 63 && __a < m_P && __b < m_P);
            if (__builtin_clzll(__a) + __builtin_clzll(__b) >= 64) return multiply_64(__a, __b);
            int64_t res = __a * __b - uint64_t(1.L / m_P * __a * __b) * m_P;
            if (res < 0)
                res += m_P;
            else if (res >= m_P)
                res -= m_P;
            return res;
        }
        constexpr _ModType pow(uint64_t __a, uint64_t __n) const {
            if constexpr (std::is_same_v<_ModType, uint64_t>)
                return pow_ld(__a, __n);
            else
                return pow_64(__a, __n);
        }
        constexpr _ModType pow_64(uint64_t __a, uint64_t __n) const {
            // assert(m_P < 1ull << 32);
            _ModType res = 1, b = mod(__a);
            while (__n) {
                if (__n & 1) res = multiply_64(res, b);
                b = multiply_64(b, b);
                __n >>= 1;
            }
            return res;
        }
        constexpr _ModType pow_128(uint64_t __a, uint64_t __n) const {
            _ModType res = 1, b = mod(__a);
            while (__n) {
                if (__n & 1) res = multiply_128(res, b);
                b = multiply_128(b, b);
                __n >>= 1;
            }
            return res;
        }
        constexpr _ModType pow_ld(uint64_t __a, uint64_t __n) const {
            _ModType res = 1, b = mod(__a);
            while (__n) {
                if (__n & 1) res = multiply_ld(res, b);
                b = multiply_ld(b, b);
                __n >>= 1;
            }
            return res;
        }
        template <typename _Tp>
        constexpr _Tp divide(_Tp __a) const {
            if (__a < m_P) return 0;
            _Tp res = m_Pinv * __a >> 64;
            if (__a - res * m_P >= m_P) res++;
            return res;
        }
        template <typename _Tp>
        constexpr std::pair<_Tp, _Tp> divmod(_Tp __a) const {
            _Tp quo = (__a * m_Pinv) >> 64, rem = __a - quo * m_P;
            if (rem >= m_P) {
                quo++;
                rem -= m_P;
            }
            return {quo, rem};
        }
    };
    using Barrett32 = Barrett<uint32_t>;
    using Barrett64 = Barrett<uint64_t>;
}
namespace OY {
    template <typename _ModType>
    struct _MontgomeryTag;
    template <>
    struct _MontgomeryTag<uint32_t> {
        using long_type = uint64_t;
        static constexpr uint32_t limit = (1u << 30) - 1;
        static constexpr uint32_t inv_loop = 4;
        static constexpr uint32_t length = 32;
    };
    template <>
    struct _MontgomeryTag<uint64_t> {
        using long_type = __uint128_t;
        static constexpr uint64_t limit = (1ull << 63) - 1;
        static constexpr uint32_t inv_loop = 5;
        static constexpr uint32_t length = 64;
    };
    template <typename _ModType>
    struct Montgomery {
        using _FastType = _ModType;
        using _LongType = typename _MontgomeryTag<_ModType>::long_type;
        _ModType m_P;
        _ModType m_Pinv;
        _ModType m_Ninv;
        Barrett<_ModType> m_brt;
        constexpr Montgomery() = default;
        constexpr explicit Montgomery(_ModType __P) : m_P(__P), m_Pinv(__P), m_Ninv(-_LongType(__P) % __P), m_brt(__P) {
            // assert((__P & 1) && __P > 1 && __P <= _MontgomeryTag<_ModType>::limit);
            for (int i = 0; i < _MontgomeryTag<_ModType>::inv_loop; i++) m_Pinv *= _ModType(2) - __P * m_Pinv;
        }
        constexpr _ModType mod() const { return m_brt.mod(); }
        constexpr _ModType mod(uint64_t __a) const { return m_brt.mod(__a); }
        constexpr _FastType init(uint64_t __a) const { return reduce(_LongType(mod(__a)) * m_Ninv); }
        constexpr _FastType raw_init(uint64_t __a) const { return reduce(_LongType(__a) * m_Ninv); }
        constexpr _FastType reduce(_LongType __a) const {
            _FastType res = (__a >> _MontgomeryTag<_ModType>::length) - _ModType(_LongType(_ModType(__a) * m_Pinv) * m_P >> _MontgomeryTag<_ModType>::length);
            if (res >= mod()) res += mod();
            return res;
        }
        constexpr _ModType reduce(_FastType __a) const {
            _ModType res = -_ModType(_LongType(__a * m_Pinv) * m_P >> _MontgomeryTag<_ModType>::length);
            if (res >= mod()) res += mod();
            return res;
        }
        constexpr _FastType multiply(_FastType __a, _FastType __b) const { return reduce(_LongType(__a) * __b); }
        constexpr _FastType pow(_FastType __a, uint64_t __n) const {
            _FastType res = reduce(_LongType(1) * m_Ninv);
            while (__n) {
                if (__n & 1) res = multiply(res, __a);
                __a = multiply(__a, __a);
                __n >>= 1;
            }
            return res;
        }
        template <typename _Tp>
        constexpr _Tp divide(_Tp __a) const { return m_brt.divide(__a); }
        template <typename _Tp>
        constexpr std::pair<_Tp, _Tp> divmod(_Tp __a) const { return m_brt.divmod(__a); }
    };
    using Montgomery32 = Montgomery<uint32_t>;
    using Montgomery64 = Montgomery<uint64_t>;
}
namespace OY {
    template <typename _Elem>
    constexpr bool isPrime(_Elem n) {
        if (std::is_same_v<_Elem, uint32_t> || n <= UINT32_MAX) {
            if (n <= 1) return false;
            if (n == 2 || n == 7 || n == 61) return true;
            if (n % 2 == 0) return false;
            Barrett32 brt(n);
            uint32_t d = (n - 1) >> __builtin_ctz(n - 1);
            for (auto &&a : {2, 7, 61}) {
                uint32_t s = d, y = brt.pow_64(a, s);
                while (s != n - 1 && y != 1 && y != n - 1) {
                    y = brt.multiply_64(y, y);
                    s <<= 1;
                }
                if (y != n - 1 && s % 2 == 0) return false;
            }
            return true;
        } else {
            // assert(n < 1ull < 63);
            if (n % 2 == 0) return false;
            Montgomery64 mg(n);
            uint64_t d = (n - 1) >> __builtin_ctzll(n - 1), one = mg.init(1);
            for (auto &&a : {2, 325, 9375, 28178, 450775, 9780504, 1795265022}) {
                uint64_t s = d, y = mg.pow(mg.init(a), s), t = mg.init(n - 1);
                while (s != n - 1 && y != one && y != t) {
                    y = mg.multiply(y, y);
                    s <<= 1;
                }
                if (y != t && s % 2 == 0) return false;
            }
            return true;
        }
    }
    constexpr auto isPrime32 = isPrime<uint32_t>;
    constexpr auto isPrime64 = isPrime<uint64_t>;
}
namespace OY {
    template <typename _Elem>
    constexpr _Elem gcd(_Elem a, _Elem b) {
        if (!a || !b) return a | b;
        int i = std::__countr_zero(a), j = std::__countr_zero(b), k = std::min(i, j);
        a >>= i;
        b >>= j;
        while (true) {
            if (a < b) std::swap(a, b);
            if (!(a -= b)) break;
            a >>= std::__countr_zero(a);
        }
        return b << k;
    }
    template <typename _Elem>
    constexpr _Elem lcm(_Elem a, _Elem b) { return a && b ? a / gcd<_Elem>(a, b) * b : 0; }
    constexpr auto gcd32 = gcd<uint32_t>;
    constexpr auto gcd64 = gcd<uint64_t>;
    constexpr auto lcm32 = lcm<uint32_t>;
    constexpr auto lcm64 = lcm<uint64_t>;
}
namespace OY {
    struct Pollard_Rho {
        static constexpr uint64_t batch = 128;
        static inline std::mt19937_64 s_rander;
        template <typename _Elem>
        static _Elem pick(_Elem __n) {
            // assert(!isPrime<_Elem>(__n));
            if (__n % 2 == 0) return 2;
            static Montgomery<_Elem> mg;
            if (mg.mod() != __n) mg = Montgomery<_Elem>(__n);
            std::uniform_int_distribution<_Elem> distribute(2, __n - 1);
            _Elem v0, v1 = mg.init(distribute(s_rander)), prod = mg.init(1), c = mg.init(distribute(s_rander));
            for (int i = 1; i < batch; i <<= 1) {
                v0 = v1;
                for (int j = 0; j < i; j++) v1 = mg.multiply(v1, v1) + c;
                for (int j = 0; j < i; j++) {
                    v1 = mg.multiply(v1, v1) + c;
                    prod = mg.multiply(prod, v0 > v1 ? v0 - v1 : v1 - v0);
                    if (!prod) return pick(__n);
                }
                if (_Elem g = gcd<_Elem>(prod, __n); g > 1) return g;
            }
            for (int i = batch;; i <<= 1) {
                v0 = v1;
                for (int j = 0; j < i; j++) v1 = mg.multiply(v1, v1) + c;
                for (int j = 0; j < i; j += batch) {
                    for (int k = 0; k < batch; k++) {
                        v1 = mg.multiply(v1, v1) + c;
                        prod = mg.multiply(prod, v0 > v1 ? v0 - v1 : v1 - v0);
                        if (!prod) return pick(__n);
                    }
                    if (_Elem g = gcd<_Elem>(prod, __n); g > 1) return g;
                }
            }
            return __n;
        }
        template <typename _Elem>
        static auto decomposite(_Elem __n) {
            struct node {
                _Elem prime;
                uint32_t count;
            };
            std::vector<node> res;
            auto dfs = [&](auto self, _Elem cur) -> void {
                if (!OY::isPrime<_Elem>(cur)) {
                    _Elem a = pick<_Elem>(cur);
                    self(self, a);
                    self(self, cur / a);
                } else {
                    auto find = std::find_if(res.begin(), res.end(), [cur](auto x) { return x.prime == cur; });
                    if (find == res.end())
                        res.push_back({cur, 1u});
                    else
                        find->count++;
                }
            };
            if (__n % 2 == 0) {
                res.push_back({2, uint32_t(std::__countr_zero(__n))});
                __n >>= std::__countr_zero(__n);
            }
            if (__n > 1) dfs(dfs, __n);
            std::sort(res.begin(), res.end(), [](auto &x, auto &y) { return x.prime < y.prime; });
            return res;
        }
        template <typename _Elem>
        static std::vector<_Elem> getFactors(_Elem __n) {
            auto pf = decomposite(__n);
            std::vector<_Elem> res;
            _Elem count = 1;
            for (auto [p, c] : pf) count *= c + 1;
            res.reserve(count);
            auto dfs = [&](auto self, int i, _Elem prod) -> void {
                if (i == pf.size())
                    res.push_back(prod);
                else {
                    auto [p, c] = pf[i];
                    self(self, i + 1, prod);
                    while (c--) self(self, i + 1, prod *= p);
                }
            };
            dfs(dfs, 0, 1);
            std::sort(res.begin(), res.end());
            return res;
        }
        template <typename _Elem>
        static _Elem EulerPhi(_Elem __n) {
            for (auto [p, c] : decomposite(__n)) __n = __n / p * (p - 1);
            return __n;
        }
    };
}
void solve(){
	int n;
	cin >> n;
	map <ll,int> cnt1,cnt2;
	rep(i,1,n) {
		cin >> a[i];
		cnt1[a[i]] ++;
	}
	ll ans = 0;
	for(auto [x,c] : cnt1) {
	    auto fac = OY::Pollard_Rho::decomposite<uint32_t>(x);
	    vector <int> v1,v2;
	    v1.pb(1),v2.pb(1);
	    if(c >= 3) ans += 1ll * c * (c - 1) * (c - 2);
	    for(auto [y,cc] : fac) {
	        for(int i = 1;i + 1 <= cc;i += 2) {
	            int ssz = sz(v1);
	            for(int j = 0;j < ssz;j ++) {
	                v1.pb(v1[j] * y);
	                v2.pb(v2[j] * y * y);
	            }
	        }
	    }
	    sort(all(v1));
	    sort(all(v2));
	    v1.erase(unique(all(v1)),v1.end());
	    v2.erase(unique(all(v2)),v2.end());
	    for(int i = 0;i < sz(v1);i ++) {
	        if(v1[i] == 1 || v2[i] == 1) continue;
	        if(cnt2.count(x / v1[i]) && cnt2.count(x / v2[i])) {
	            ans += 1ll * c * cnt2[x / v1[i]] * cnt2[x / v2[i]];
	        }
	    }
	    cnt2[x] = c;
	}
	cout << ans << '\n';
}

int main()
{
    ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T = 1;
	cin >> T;
	while(T --) solve();
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/462925.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数据库基础篇 《16.变量、流程控制与游标》

数据库基础篇 《16.变量、流程控制与游标》

数据库基础篇 《16.变量、流程控制与游标》 1. 变量 在MySQL数据库的存储过程和函数中&#xff0c;可以使用变量来存储查询或计算的中间结果数据&#xff0c;或者输出最终的结果数据。 在 MySQL 数据库中&#xff0c;变量分为系统变量以及用户自定义变量。 1.1 系统变量 1…
阅读更多...
深度学习入门：多层感知机实现异或门

深度学习入门：多层感知机实现异或门

文章目录 前言感知机2层感知机实现异或门总结参考文献&#xff1a; 前言 最近又开始看深度学习的内容了&#xff0c;好久不用忘得差不多了&#xff0c;先从最简单的感知机入手了&#xff0c;这里记录下用2层感知机实现异或门。 感知机 什么是感知机呢&#xff1f;这里粗浅的介…
阅读更多...
初步了解c语言（三）

初步了解c语言（三）

注&#xff1a;此篇文章仅限初步了解&#xff0c;本小白后续会持续进行详解。 目录&#xff1a; 函数数组数组的定义数组的下标 操作符常见关键字关键字static的使用修饰局部变量修饰全局变量修饰函数 关键字register的大概了解#define定义常量和宏结构体&#x1f49e;结尾 函数…
阅读更多...
RuntimeError: “LayerNormKernelImpl“ not implemented for ‘Long‘解决方法

RuntimeError: “LayerNormKernelImpl“ not implemented for ‘Long‘解决方法

问题出现的场景&#xff1a; 输入&#xff1a; import torch import torch.nn as nn atorch.randint(10,[3,4]) # atorch.DoubleTensor(a) # aa.double() print(a) layer_normnn.LayerNorm(4) layer_norm(a) 我就是想测试一下经过layernorm之后的输出会变成什么样 但是报错…
阅读更多...
Pycharm中如何安装 OpenAI ——ChatGPT的python包?

Pycharm中如何安装 OpenAI ——ChatGPT的python包?

本文由 大侠(AhcaoZhu)原创&#xff0c;转载请声明。 链接: https://blog.csdn.net/Ahcao2008 Pycharm中如何安装 OpenAI ——ChatGPT的python包? 摘要背景安装1、安装前准备2、安装前提条件3、依赖库 最佳安装过程1、检查 VC2、看哪些依赖库未安装3、将未装模块写成 test02.b…
阅读更多...
js 打开资源管理器（经典范例：纯前端选择并预览图片）

js 打开资源管理器（经典范例：纯前端选择并预览图片）

效果预览 完整代码范例 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta http-equiv"X-UA-Compatible" content"IEedge" /><meta name"viewport" content"width…
阅读更多...
C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map

C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map

文章目录 哈希表模板参数改造针对模板参数V改造增加仿函数获取具体数据类型. 哈希表的正向迭代器正向迭代器中的内置成员:正向迭代器的成员函数 哈希表插入函数的修改(适用于unordered_map)一个类型K去做set和unordered_set他的模板参数的必备条件.unordered_set的模拟实现(完整…
阅读更多...
不得不的创建型模式-原型模式

不得不的创建型模式-原型模式

原型模式是一种创建型模式&#xff0c;它通过复制一个已有对象来创建新的对象&#xff0c;而无需知道新对象的具体类型。 原型模型的结构&#xff1a; 下面是一个简单的C实现原型模式的代码示例&#xff1a; #include <iostream> #include <string> #include <…
阅读更多...
React markdown 编辑器

React markdown 编辑器

react-markdown 是一款 github 上开源的适用于 react 的 markdown 组件&#xff0c;可以基本实现 markdown 的功能&#xff0c;且可以根据自己实际应用定制的 remark 组件。 安装 安装 markdown 预览插件 react-markdown npm install react-markdown或者&#xff1a; yarn …
阅读更多...
Flask+mysql简单问答网站（实现公网可访问）

Flask+mysql简单问答网站（实现公网可访问）

先到github下载仓库文件 https://github.com/QHCV/flask_mysql_blog python版本3.8&#xff0c;提前安装好Mysql数据库 1.安装python包 pip install -r requirements.txt2.修改配置文件config.py Mysql数据库用户名和密码用于发送验证码的邮箱配置 ​ 在设置->账户下开…
阅读更多...
数仓建设规划核心问题！

数仓建设规划核心问题！

小A进入一家网约车出现服务公司&#xff0c;负责公司数仓建设&#xff0c;试用期主要一项 OKR是制定数据仓库建设规划&#xff1b;因此小 A 本着从问题出发为原点&#xff0c;先对公司数仓现状进行一轮深入了解&#xff0c;理清存在问题&#xff0c;然后在以不忘初心原则提出解…
阅读更多...
提取文本的摘要snownlp模块

提取文本的摘要snownlp模块

【小白从小学Python、C、Java】 【计算机等级考试500强双证书】 【Python-数据分析】 提取文本的摘要 snownlp模块 [太阳]选择题 关于以下python代码说法错误的一项是&#xff1f; from snownlp import SnowNLP myText """ChatGPT的出现标志着人类科技发…
阅读更多...
CSS3 grid网格布局

CSS3 grid网格布局

文章目录 CSS3 grid网格布局概述grid属性说明使用grid-template-rows & grid-template-columns 定义行高和列宽grid-auto-flow 定义项目的排列顺序grid-auto-rows & grid-auto-columns 定义多余网格的行高和列宽row-gap & column-gap 设置行间距和列间距gap 简写形…
阅读更多...
Java版spring cloud 本工程项目管理系统源码-全面的工程项目管理

Java版spring cloud 本工程项目管理系统源码-全面的工程项目管理

​ ​工程项目管理系统是指从事工程项目管理的企业&#xff08;以下简称工程项目管理企业&#xff09;受业主委托&#xff0c;按照合同约定&#xff0c;代表业主对工程项目的组织实施进行全过程或若干阶段的管理和服务。 如今建筑行业竞争激烈&#xff0c;内卷严重&#xff0c…
阅读更多...
Leetcode605. 种花问题

Leetcode605. 种花问题

Every day a leetcode 题目来源&#xff1a;605. 种花问题 解法1&#xff1a;贪心 贪心思想&#xff1a;在不打破种植规则的情况下种入尽可能多的花&#xff0c;然后用“最大种植数量”和“所需要种植数量”进行大小比较即可。 设地块长度为n&#xff0c;种花的情况可分为4…
阅读更多...
分享一个菜单标签页动画，切换丝滑无比

分享一个菜单标签页动画，切换丝滑无比

先上效果图： 代码如下，复制粘贴大法拿走即可使用： <!DOCTYPE html> <html lang="en"> <head>
阅读更多...
win系统使用frp端口映射实现内网穿透，配置“任务计划程序”提高稳定性

win系统使用frp端口映射实现内网穿透，配置“任务计划程序”提高稳定性

Github下载最新版frp: https://github.com/fatedier/frp/releases/download/v0.48.0/frp_0.48.0_windows_amd64.zip 解压把frpc.exe和frpc.ini放到D:\program\frp目录下&#xff0c;修改frpc.ini内容如下&#xff1a; [common] server_addr 服务器域名或IP&#xff0c;假设…
阅读更多...
Dockerfile镜像LNMP的实战

Dockerfile镜像LNMP的实战

Dockerfile镜像LNMP的实战 环境准备关闭防火墙拉取centos:7镜像自定义网络 部署nginx&#xff08;容器IP 为 172.18.0.10&#xff09;部署mysql&#xff08;容器IP 为 172.18.0.20&#xff09;部署php&#xff08;容器IP 为 172.18.0.30&#xff09; 环境准备 关闭防火墙 [ro…
阅读更多...
taro之项目初始化模板

taro之项目初始化模板

项目初始化模板 一直以来&#xff0c;在使用 Taro CLI 的 taro init 命令创建项目时&#xff0c;CLI 会提供若干内置模板给开发者选择。但是很多团队都有自己独特的业务场景&#xff0c;需要使用和维护的模板也不尽一致&#xff0c;因此 Taro 支持把项目模板打包成一个能力赋予…
阅读更多...
JavaScript奇技淫巧：debugger拦截

JavaScript奇技淫巧：debugger拦截

debugger指令&#xff0c;一般用于调试&#xff0c;在如浏览器调试执行环境中&#xff0c;可以在JavaScript代码中产生中断。 如果想要拦截debugger&#xff0c;是不容易的&#xff0c;常用的函数替代、proxy方法均对它无效&#xff0c;如&#xff1a; window.debugger (fun…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023