2021年度训练联盟热身训练赛第一场 部分题解（待补）

最新推荐文章于 2021-03-21 15:45:43 发布
最新推荐文章于 2021-03-21 15:45:43 发布
阅读量2.1k 收藏 3
点赞数
分类专栏： 赛后记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kaka03200/article/details/114491278
版权

比赛链接：https://ac.nowcoder.com/acm/contest/12606#question

目录

A Weird Flecks, But OK

队友写的，求最小外接圆直径

/*Siberian Squirrel*/
/*Cute JinFish*/
#include<bits/stdc++.h>

#define IO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
//#define ACM_LOCAL

using namespace std;
typedef long long ll;

const double PI = acos(-1);
const double eps = 1e-4;
/*const int MOD = 998244353, r = 119, k = 23, g = 3;
const int MOD = 1004535809, r = 479, k = 21, g = 3;*/
const int MOD = 1e9 + 7;
const int M = 1e7 + 10;
const int N = 4e5 + 10;

int dcmp(double x) {
	if(fabs(x) < eps) return 0;
	else return x < 0? -1: 1;
}
//inline int rnd(){static int seed=2333;return seed=(((seed*666666ll+20050818)%998244353)^1000000007)%1004535809;}

int n;
struct nodee {
	double x, y, z;
} _p[N];
struct node {
	double x, y;
} p[N];

node c; ///圆心
double r;   ///半径

int sgn(double x) {
	if (fabs(x) < eps)
		return 0;
	else
		return x < 0 ? -1 : 1;
}

double Distance(node A, node B) { ///两点距离
	return hypot(A.x - B.x, A.y - B.y); ///hypot(a, b)求以a, b为直角边的直角三角形斜边长
}

///求三角形abc的外接圆圆心
node circle_center(const node a, const node b, const node c) {
	node center;
	double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1 * a1 + b1 * b1) / 2;
	double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2 * a2 + b2 * b2) / 2;
	double d = a1 * b2 - a2 * b1;
	center.x = a.x + (c1 * b2 - c2 * b1) / d;
	center.y = a.y + (a1 * c2 - a2 * c1) / d;
	return center;
}

///求最小圆覆盖，返回圆心c和半径r:
void min_cover_circle(int n) {
	random_shuffle(p, p + n);             ///打乱所有点
	c = p[0];
	r = 0;                    ///第一个点
	for (int i = 1; i < n; ++i) {      ///剩下所有点
		if (sgn(Distance(p[i], c) - r) > 0) { ///pi在圆外部
			c = p[i];
			r = 0;                ///将圆心设为pi半径为0
			for (int j = 0; j < i; ++j) { ///重新检查前面的点
				if (sgn(Distance(p[j], c) - r) > 0) { ///两点定圆
					c.x = (p[i].x + p[j].x) / 2;
					c.y = (p[i].y + p[j].y) / 2;
					r = Distance(p[j], c);
					for (int k = 0; k < j; ++k) {
						if (sgn(Distance(p[k], c) - r) > 0) {
							c = circle_center(p[i], p[j], p[k]);
							r = Distance(p[i], c);
						}
					}
				}
			}
		}
	}
}

inline void solve(ll res = 0) {
	double minn = 1.0 * INT_MAX;
	for(int i = 0; i < n; ++ i) {
		p[i].x = _p[i].x;
		p[i].y = _p[i].y;
	}
	min_cover_circle(n);
//	cout << "1:" << setprecision(10) << r * 2 << endl;
	minn = min(minn, 2.0 * r);
	for(int i = 0; i < n; ++ i) {
		p[i].x = _p[i].x;
		p[i].y = _p[i].z;
	}
	min_cover_circle(n);
//	cout << "2:" << setprecision(10) << r * 2 << endl;
	minn = min(minn, 2.0 * r);
	for(int i = 0; i < n; ++ i) {
		p[i].x = _p[i].z;
		p[i].y = _p[i].y;
	}
	min_cover_circle(n);
//	cout << "3:" << setprecision(10) << r * 2 << endl;
	minn = min(minn, 2.0 * r);
	cout << setprecision(10) << minn << endl;
}


int main() {
	IO;
#ifdef ACM_LOCAL
	freopen("input", "r", stdin);
	freopen("output", "w", stdout);
#endif
	int o = 1;
//	cin >> o;
	while(o --) {
		cin >> n;
		for(int i = 0; i < n; ++ i) {
			cin >> _p[i].x >> _p[i].y >> _p[i].z;
		}
		solve();
	}
	return 0;
}

B Code Names

一开始觉得是二分图，然后搞了半天没有想到构造二分图的方法 ，浪费了1个多小时在这个上面还是挺傻逼的，稍加思考其实就是个带花树的裸题而已，不懂带花树的搜一下一般图的最大匹配，然后这题就是个最大独立集也就是n-最大匹配数。

#include <bits/stdc++.h>
using namespace std;
#define re register
#define fi first
#define se second
const int N = 1e5 + 10;
const int M = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
int n;
string s[N];
char ai[N], bi[N];
int m,cnt,last[N],ty[N],tic[N],tim,f[N],match[N],pre[N];
struct edge{int to,next;}e[300005];
queue<int> que;

int read()
{
    int x=0,f=1;char ch=getchar();
    while (ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

void addedge(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;
}

int find(int x)
{
    if (f[x]==x) return x;
    else return f[x]=find(f[x]);
}

int lca(int x,int y)
{
    for (tim++;;swap(x,y))
        if (x)
        {
            x=find(x);
            if (tic[x]==tim) return x;
            tic[x]=tim;x=pre[match[x]];
        }
}

void shrink(int x,int y,int p)
{
    while (find(x)!=p)
    {
        pre[x]=y;y=match[x];
        if (ty[y]==2) ty[y]=1,que.push(y);
        if (find(x)==x) f[x]=p;
        if (find(y)==y) f[y]=p;
        x=pre[y];
    }
}

bool aug(int s)
{
    for (int i=1;i<=n;i++) f[i]=i,ty[i]=pre[i]=0;
    while (!que.empty()) que.pop();
    que.push(s);ty[s]=1;
    while (!que.empty())
    {
        int x=que.front();que.pop();
        for (int i=last[x],y=e[i].to;i;i=e[i].next,y=e[i].to)
        {
            if (find(x)==find(y)||ty[y]==2) continue;
            if (!ty[y])
            {
                ty[y]=2;pre[y]=x;
                if (!match[y])
                {
                    for (int tmp;y;y=tmp,x=pre[y])
                        tmp=match[x],match[x]=y,match[y]=x;
                    return 1;
                }
                else ty[match[y]]=1,que.push(match[y]);
            }
            else if (ty[y]==1)
            {
                int p=lca(x,y);
                shrink(x,y,p);
                shrink(y,x,p);
            }
        }
    }
    return 0;
}

void solve() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> s[i];
    for (int i = 1; i <= n; i++) {
        for (int j = i+1; j <= n; j++) {
            int num = 0;
            for (int k = 0; k < s[i].size(); k++) {
                if (s[i][k] != s[j][k]) {
                    num++;
                    if (num <= 2) ai[num] = s[i][k], bi[num] = s[j][k];
                }
            }
            if (num == 2 && ai[1] == bi[2] && ai[2] == bi[1]) addedge(i, j);
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        if (!match[i] && aug(i)) ans++;
    }
    cout << n - ans << endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

D Some Sum

队友写的签到题

/*Siberian Squirrel*/
/*Cute JinFish*/
#include<bits/stdc++.h>

#define IO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
//#define ACM_LOCAL

using namespace std;
typedef long long ll;

const double PI = acos(-1);
const double eps = 1e-6;
/*const int MOD = 998244353, r = 119, k = 23, g = 3;
const int MOD = 1004535809, r = 479, k = 21, g = 3;*/
const int MOD = 1e9 + 7;
const int M = 1e7 + 10;
const int N = 4e5 + 10;

int dcmp(double x) {
	if(fabs(x) < eps) return 0;
	else return x < 0? -1: 1;
}
//inline int rnd(){static int seed=2333;return seed=(((seed*666666ll+20050818)%998244353)^1000000007)%1004535809;}

int n; 

inline void solve(ll res = 0) {
	if(n & 1) cout << "Either" << endl;
	else if((n / 2) % 2 == 0) cout << "Even" << endl;
	else cout << "Odd" << endl;
}


int main() {
	IO;
#ifdef ACM_LOCAL
	freopen("input", "r", stdin);
	freopen("output", "w", stdout);
#endif
	int o = 1;
//	cin >> o;
	while(o --) {
		cin >> n;	
		solve();
	}
	return 0;
}

E Early Orders

因为取牌是有后效性的，也就是说你要提前处理出所有数值的牌还剩多少张，然后就是用单调栈进行贪心了。我们要维护单调栈内递增，这样可以做到当前最优的状态，然后配合预处理的牌的张数进行出栈。有一个地方要特殊注意一下，如果这个数值已经在栈内了，那就直接过。

#include <bits/stdc++.h>
using namespace std;
#define re register
#define fi first
#define se second
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
int a[N], cnt[N];
int stk[N], tp, vis[N];
void solve() {
    int n, m; cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> a[i], cnt[a[i]]++;
    for (int i = 1; i <= n; i++) {
        if (!vis[a[i]]) {
            while (tp && a[stk[tp]] > a[i] && cnt[a[stk[tp]]]) {
                vis[a[stk[tp]]] = 0;
                tp--;
            }
            stk[++tp] = i;
            vis[a[i]] = 1;
        }
        //for (int j = 1; j <= tp; j++) cout << a[stk[j]] << " ";
        //cout << endl;
        cnt[a[i]]--;
    }
    for (int i = 1; i <= tp; i++) cout << a[stk[i]] << " ";
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

F Pulling Their Weight

数值很小，直接处理前缀和后缀和，枚举每个数就可以了，简单签到题

#include <bits/stdc++.h>
using namespace std;
#define re register
#define fi first
#define se second
const int N = 1e5 + 10;
const int M = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
int n, m, a[N];
ll pre[N], back[N], cnt[N];
void solve() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i], cnt[a[i]]++;
    for (int i = 1; i <= 1e5; i++) pre[i] = pre[i-1] + cnt[i] * i;
    for (int i = 1e5; i >= 1; i--) back[i] = back[i+1] + cnt[i] * i;
    for (int i = 1; i <= 1e5; i++) {
        if (pre[i-1] == back[i+1]) {
            printf("%d\n", i);
            return;
        }
    }
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

H On Average They’re Purple

题目花里胡哨，其实就是一个bfs（最短路-1也可以）

#include <bits/stdc++.h>
using namespace std;
#define re register
#define fi first
#define se second
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
typedef pair<int, int> PII;
struct Edge {
    int to, next, w;
}e[M];
int h[N], cnt, vis[N], dis[N];
void add(int u, int v) {
    e[cnt].to = v;
    e[cnt].next = h[u];
    h[u] = cnt++;
}
void bfs(int s) {
    queue<int> que;
    memset(dis, 0x3f, sizeof dis);
    for (int i = h[s]; ~i; i = e[i].next) dis[e[i].to] = 0, que.push(e[i].to);
    vis[s] = 1; dis[s] = 0;
    while (que.size()) {
        int now = que.front();
        que.pop();
        vis[now] = 1;
        for (int i = h[now]; ~i; i = e[i].next) {
            int v = e[i].to;
            dis[v] = min(dis[v], dis[now] + 1);
            if (!vis[v]) que.push(v);
        }
    }
}
void solve() {
    int n, m; cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= m; i++) {
        int u, v; cin >> u >> v;
        add(u, v); add(v, u);
    }
    bfs(1);
    cout << dis[n] << endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

I Full Depth Morning Show

树形dp，需要预处理一些东西
T代表子树节点权值和
siz代表子树子节点个数
dist代表所有子节点到当前节点的距离和
disT代表所有子节点到当前节点距离*子节点的和
然后就可以开始转移了
根转移写得少，代码略丑

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define re register
#define fi first
#define se second
const int N = 3e5 + 10;
const int M = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
typedef pair<int, int> PII;
ll T[N], dist[N], disT[N], val[N], siz[N], ans[N];
int cnt, h[N], n, m;
struct Edge {
    int to, next, w;
}e[M];
void add(int u, int v, int w) {
    e[cnt].to = v;
    e[cnt].w = w;
    e[cnt].next = h[u];
    h[u] = cnt++;
}

void dfs1(int u, int fa) {
    siz[u] = 1; T[u] = val[u];
    for (int i = h[u]; ~i; i = e[i].next) {
        int v = e[i].to;
        if (v == fa) continue;
        dfs1(v, u);
        siz[u] += siz[v];
        T[u] += T[v];
        dist[u] += siz[v] * e[i].w + dist[v];
        disT[u] += e[i].w * T[v] + disT[v];
    }
}
void dfs2(int u, int fa) {
    for (int i = h[u]; ~i; i = e[i].next) {
        int v = e[i].to;
        if (v == fa) continue;
        dist[v] += dist[u] - dist[v] - e[i].w * siz[v] + (siz[u] - siz[v]) * e[i].w;
        disT[v] += disT[u] - disT[v] - e[i].w * T[v] + (T[u] - T[v]) * e[i].w;
        ans[v] = val[v] * dist[v] + disT[v];
        siz[v] = siz[u];
        T[v] = T[u];
        dfs2(v, u);
    }
}
void solve() {
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i++) cin >> val[i];
    for (int i = 1; i <= n-1; i++) {
        int u, v, w; cin >> u >> v >> w;
        add(u, v, w), add(v, u, w);
    }
    dfs1(1, 0);
    ans[1] = disT[1] + dist[1] * val[1];
    dfs2(1, 0);
    for (int i = 1; i <= n; i++) printf("%lld\n", ans[i]);
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

J This Ain’t Your Grandpa’s Checkerboard

签到题

#include <bits/stdc++.h>
using namespace std;
#define re register
#define fi first
#define se second
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const double eps = 1e-4;
const int MOD = 1e9 + 7;
typedef long long ll;
typedef pair<int, int> PII;
int mp[100][100];
void solve() {
    int n; cin >> n;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            char c; cin >> c;
            if (c == 'W') mp[i][j] = 0;
            else mp[i][j] = 1;
        }
    }
    int f = 0;
    for (int i = 1; i <= n; i++) {
        int black = 0, white = 0;
        for (int j = 1; j <= n; j++) {
            if (mp[i][j] == 0) white++;
            else black++;
        }
        if (white != black) f = 1;
    }
    for (int i = 1; i <= n; i++) {
        int black = 0, white = 0;
        for (int j = 1; j <= n; j++) {
            if (mp[j][i] == 0) white++;
            else black++;
        }
        if (white != black) f = 1;
    }
    for (int i = 1; i <= n; i++) {
        int tmp = 1;
        for (int j = 2; j <= n; j++) {
            if (mp[i][j] == mp[i][j-1]) tmp++;
            else tmp = 1;
            if (tmp >= 3) f = 1;
        }
    }
    for (int i = 1; i <= n; i++) {
        int tmp = 1;
        for (int j = 2; j <= n; j++) {
            if (mp[j][i] == mp[j-1][i]) tmp++;
            else tmp = 1;
            if (tmp >= 3) f = 1;
        }
    }
    if (f) cout << 0 << endl;
    else cout << 1 << endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}
kaka0010
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
2021-2022收藏资料离散数学习题解第一部分(集合论部分).doc
09-26
2021年09月16日
2021年度训练联盟热身训练赛第一场
qq_45288870的博客
03-07 1665
A Weird Flecks, But OK 最小圆覆盖模板题，大部分都是用的板子吧，来个三分套三分吧。（跑得比较慢） #include <bits/stdc++.h> using namespace std; typedef long long ll; const int mod=1e9+7; const double eps=1e-6; const int N = 5010, M = 1e6+10; int n,k; double x[N],y[N],z[N]; double check3
【Nowcoder】2021年度训练联盟热身训练赛第一场 Early Orders | 单调栈思想
一只酷酷光儿的博客
03-07 401
UCF Local Programming Contest 2016（Practice）的题目 题目大意: 给出一个长度为NNN的序列，你需要找到字典序最小的长度为mmm的子序列满足该子序列包含(1 m)(1~m)(1 m) 题目思路: 训练的时候，看到这个题目，直接送上了mlog2nmlog^2nmlog2n的解法… AcAcAc了之后，仔细考虑了一下，应该是有O(n))O(n))O(n))解法的 所以训练完后就可以补一下了。 考虑类单调栈的思想。 因为字典序最小，所以考虑对于新来.
On Average They‘re Purple （bfs求最短路）
Spike的秃头之路
03-08 213
题目链接：https://ac.nowcoder.com/acm/contest/12606/H 由分析得所求颜色变化数为最短路径上步数减一 利用bfs求最短路径 #include <iostream> #include <cstdio> #include <cmath> #include <vector> #include <queue> using namespace std; #define ll long long const int IN
2021-2022收藏资料离散数学习题解第一部分(集合论部分)96369.doc
09-26
2021年09月16日
3、CSP-J第一轮学军信友队开放模拟赛_题解.pdf
10-08
3、CSP-J第一轮学军信友队开放模拟赛_题解.pdf
电工学题解：第一章 电路分析基础.doc
11-26
电工学题解：第一章 电路分析基础.doc
电工学题解：第十一章 数字电路修改.doc
11-29
电工学题解：第十一章 数字电路修改.doc
微信小程序以7天为周期连续签到7天功能效果的示例代码
11-19
此功能以1,2,3,4,5,6,7这样为一周期，连续签到的功能； 通过计算是否为整除7天计算，每7天后切换数目，从而改变周期表、
mosquitto-1.6.4-install-windows-x64.zip
03-08
mqtt 库，服务器
#牛客2021年度训练联盟热身训练赛第一场总体概述
欧阳小百合
03-08 444
总体概述： 这是我新组队以后打的第一场比赛。 就这场比赛来看，现在的两个队友，一个是debug自动机·图论dp一遍过选手，另外一个是前OI·轻松手写线段树·不擅长计算几何（指一遍秒最小覆盖圆问题）选手。 感觉得更加努力才行了。 从来没想过自己能走那么远，但是现在我开始坚信自己能走到更远的地方！ 比赛情况： 排名：61/1302 过题：9/11 过题情况： A.Weird Flecks, But OK 知识点：最小覆盖圆 先对立体图形投影化成二维，然后套最小覆盖圆板子。 我根本没来得及看题，是的就是那么拉垮。
2021年度训练联盟热身训练赛第一场 ICPC North Central NA Contest 2019
weixin_46283740的博客
03-07 459
2021年度训练联盟热身训练赛第一场 ICPC North Central NA Contest 2019 比赛题目： 这学期的周赛都将以训练联盟组织的牛客网上的比赛来进行。这是本学期的第一场比赛，也是我第一次参加五个小时的ICPC模拟赛，过了6道题，表现就目前而言算比较满意了，但赛后看了其他题目别人AC的代码，自己还是有很大提升空间的。继续努力！ 以下是我通过题目的AC代码： A题 Weird Flecks, But OK 最小覆盖圆的模板题，也差不多是第一次做计算几何题，照着模板敲就可以通过了。 #i
【2021年度训练联盟热身训练赛第三场】Circuit Math（python）
李响
03-21 438
import math import cmath import sys import string import heapq import bisect import copy from queue import Queue, PriorityQueue, LifoQueue from collections import Counter, deque from itertools import permutations, combinations from functools import cmp_to_
2021年度训练联盟热身训练赛第一场 E题 Early Orders(栈模拟)
the best 的博客
03-07 272
题意： 给出一个数组，只包含 111 到 kkk 的数，且每个数至少出现一次，求一个子序列，满足111 到 kkk 的全排列。 题解： 用栈去模拟，当某个数 xxx 不在栈中，则一直与栈顶比较，直到 xxx 大于栈顶或栈顶元素已经全部出现完， 当 xxx 已经出现在栈中，那么直接跳过，不用考虑，因为此时栈中 xxx 后面的元素要么是单调递增的，要么存在某个数已经全部出现完，所以不需要再考虑。 代码： #include<cstdio> #include<iostream> #inclu
2021数学建模美赛C题代码.zip
04-24
最全的数学建模美赛C题和代码、大量刷题题库、逻辑清晰易于学习
这是一个保存Springboot+MyBaits项目的仓库.zip
最新发布
04-24
springboot框架 一、Spring Boot基础应用 Spring Boot特征 概念： 约定优于配置，简单来说就是你所期待的配置与约定的配置一致，那么就可以不做任何配置，约定不符合期待时才需要对约定进行替换配置。 特征： 1. SpringBoot Starter：他将常用的依赖分组进行了整合，将其合并到一个依赖中，这样就可以一次性添加到项目的Maven或Gradle构建中。 2,使编码变得简单，SpringBoot采用 JavaConfig的方式对Spring进行配置，并且提供了大量的注解，极大的提高了工作效率，比如@Configuration和@bean注解结合，基于@Configuration完成类扫描，基于@bean注解把返回值注入IOC容器。 3.自动配置：SpringBoot的自动配置特性利用了Spring对条件化配置的支持，合理地推测应用所需的bean并自动化配置他们。 4.使部署变得简单，SpringBoot内置了三种Servlet容器，Tomcat，Jetty,undertow.我们只需要一个Java的运行环境就可以跑SpringBoot的项目了
课设&大作业-毕业设计精品课程网站，采用的技术是 SSM 框架和 Shiro.zip
04-24
【资源说明】【毕业设计】 1、该资源内项目代码都是经过测试运行成功，功能正常的情况下才上传的，请放心下载使用。 2、适用人群：主要针对计算机相关专业(如计科、信息安全、数据科学与大数据技术、人工智能、通信、物联网、数学、电子信息等)的同学或企业员工下载使用，具有较高的学习借鉴价值。 3、不仅适合小白学习实战练习，也可作为大作业、课程设计、毕设项目、初期项目立项演示等，欢迎下载，互相学习，共同进步！
csp-s2提高组2021第二轮题解
09-25
2021年第二轮题解分为以下几个部分。 第一题是关于石头游戏的思考。题目给出了一堆石头的数量，两位玩家轮流选择石头进行取走，每次可以取走1个或者2个石头，最后无法继续取走者输掉游戏。通过观察可以发现，如果一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值