2020牛客国庆集训派对day4

于 2021-04-27 19:57:13 发布
阅读量137 收藏
点赞数
分类专栏： 区域赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ickchen2/article/details/116207714
版权
这篇博客涵盖了多种算法问题的解决方案，包括字符串的数字比较、等差数列查找、紧急疏散路径规划、最短非子序列构造、数组排序优化以及颜色树的更新。涉及字符串分割、二叉树的LCA计算、单峰数组构建和全排列还原等概念。
摘要由CSDN通过智能技术生成

A Digits Are Not Just Characters

  • 给出n个字符串si和一个base串s0，问si和s0的大小关系。

比较的时候，先将s分割成数字串和字符串，然后对应去比较。

 

#include <bits/stdc++.h>
using namespace std;
bool isdig(char c){
  return c>='0'&&c<='9';
}

int check1(string s1, string s2){
  int num1 = 0, num2 = 0;
  string str1, str2;
  if(isdig(s1[0])){
    num1 = atoi(s1.c_str());
  }
  else {
    str1= s1;
  }
  if(isdig(s2[0])){
    num2 = atoi(s2.c_str());
  }else str2 = s2;
  if(num1 || num2){
    if(num1==0) return 1;
    if(num2==0) return -1;
    if(num1==num2)return 0;
    return num1<num2?-1:1;
  }
  if(str1==str2)return 0;
  return str1<str2?-1:1;
}

vector<string> parse(string s){
  vector<string> ret;
  string tmp;
  for(int i = 0; i< s.size();++i){
    if(i==0 || (isdig(s[i-1])^isdig(s[i]))){
      if(tmp.size()) ret.push_back(tmp);
      tmp = s[i];
    }
    else {
      tmp += s[i];
    }
  }
  if(tmp.size()) ret.push_back(tmp);
  return ret;
}

bool check(string s0, string s1){
  vector<string> ss1 = parse(s0);
  vector<string> ss2 = parse(s1);
  int n = ss1.size(), m = ss2.size();
  for(int i = 0; i < min(n,m); ++i){
    int ret = check1(ss1[i],ss2[i]);
    if(ret==0)continue;
    return ret<0;
  }
  return n<m;
}

int main(){
  int n;
  cin>>n;
  string s0;
  cin>>s0;
  
  for(int i = 0; i < n; ++i){
    string s;
    cin>>s;
    if(check(s,s0))printf("-\n");
    else printf("+\n");
  }
}

 

B Arithmetic Progressions

  • 求一个最长的等差数列

枚举i，j为等差数列的最后两个，然后dp[i][j] = dp[j][(2*j-i)]+1

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

int dp[5010][5010];
int a[5010];
int main(){
  memset(dp,0,sizeof(dp));
  int n;
  cin>>n;
  map<int,int> pos;
  for(int i = 0; i < n; ++i){
    cin>>a[i];
  }
  
  sort(a,a+n);
  int ans = 2;
  for(int i = 0; i < n; ++i){
    dp[i][i] = 1;
    for(int j = i-1; j>=0;--j){
      dp[i][j] = 2;
      int pre = 2*a[j]-a[i];
      if(pos.find(pre)==pos.end())continue;
      dp[i][j] = max(dp[i][j], dp[j][pos[pre]]+1);
      ans = max(ans, dp[i][j]);
    }
    pos[a[i]]=i;
  }
  cout<<ans<<endl;
}

 

C Emergency Evacuation

  • 给出一个n*m的格子图，然后图上的人都要跑出去，每一个格子不能同时站两个人，问最短时间

由于出口只有一个，因此反过来算从出口进去回到原来位置的最短时间。

按照距离排序，那么每个人的时间就是等待时间加上回去的距离。进去之后前面的肯定不会卡住后面的。

 

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

int main(){
  vector<pair<int,int>> x;
  int r,s,p;
  scanf("%d%d%d",&r,&s,&p);
  for(int i = 0; i < p; ++i){
    int a,b;
    scanf("%d%d",&a,&b);
    if(b>s)b = 2*s +1 - b;
    a = r+1-a;
    x.push_back(make_pair(a,b));
  }
  auto cmp = [&](const pair<int,int> &a, const pair<int,int> &b){
    int dis1 = (s-a.second+1) + a.first;
    int dis2 = (s-b.second+1) + b.first;
    return dis1>dis2;
  };
  sort(x.begin(),x.end(),cmp);
  
  int ans =0;
  for(int i = 0; i < p; ++i){
    int dis = (s-x[i].second+1) + x[i].first;
    ans = max(ans, dis + i);
  }
  cout<<ans<<endl;
}

 

D Shortest Common Non-Subsequence

  • 求一个最短串，不是A,B两个的子串

其实题目就是求一个最短的串，然后能跑满A,B两个串。

dp[i][j]表示在A的第i位B的第j位开始匹配，匹配到最后时的最短距离。

那么有两种选择，去0或者去1.转移就是dp[i][j] = min(dp[next[i][0]][next[j][0]], dp[next[i][1]][next[j][1]])+1

这样就可以求出从00开始的最短串了。然后构造这个最短串，末尾加个0就是答案了。（其实这个0不用加，直接跑到两个串末尾就自动加上去了）

 

#include <stdio.h>
#include <string>
#include <string.h>
#include <iostream>
using namespace std;

int dp[4010][4010];
int nt1[4010][2],nt2[4010][2];
int path[4010][4010];
int len1,len2;

int get_min(int x, int y){
	if(x==-1) return y;
	if(y==-1) return x;
	return min(x,y);
}

string ans;
void get_ans(int i, int j){
	if(i==len1+1&&j==len2+1){
		return;
	}
	ans+= path[i][j] + '0';
	get_ans(nt1[i][path[i][j]],nt2[j][path[i][j]]);
}

int main(){
  string s1,s2;
  cin>>s1>>s2;
  if(s1.size() > s2.size()) swap(s1,s2);

  len1 = s1.size(), len2 = s2.size();
  nt1[len1+1][0] = nt1[len1+1][1] = len1+1;
  nt2[len2+1][0] = nt2[len2+1][1] = len2+1;

  for(int i = len1;i>=0;--i){
    nt1[i][0] = nt1[i+1][0];
    nt1[i][1] = nt1[i+1][1];
    nt1[i][s1[i]-'0'] = i+1;
  }

  for(int i = len2; i>=0;--i){
    nt2[i][0] = nt2[i+1][0];
    nt2[i][1] = nt2[i+1][1];
    nt2[i][s2[i]-'0']=i+1;
  }

  dp[len1+1][len2+1]=0;
  for(int i = len1+1; i>=0;--i){
    for(int j = len2+1; j >=0;--j){
		if(i==len1+1&&j==len2+1)continue;
      int ret1 = dp[nt1[i][0]][nt2[j][0]]+1;
      int ret2 = dp[nt1[i][1]][nt2[j][1]]+1;
      if(ret1<=ret2){
        dp[i][j] = ret1;
        path[i][j] = 0;
      }
      else {
        dp[i][j] = ret2;
        path[i][j] = 1;
      }
    }
  }
  get_ans(0,0);
  cout<<ans<<endl;
}

 

F What Goes Up Must Come Down

  • 给出一个n个元素的数组，可以交换相邻的两个数，问至少需要交换多少次，使得数组是单峰的。

 

最小的那个数肯定是在数组的最左或者最后，那么把最小的那个移到边缘之后，就变成了一个子问题了。

因此从小打到枚举数，判断去左还是去右。

 

#include <bits/stdc++.h>

using namespace std;

int sum[100010], lt[100010],rt[100010];
int a[100010];
int max_n;
void add(int x){
  for(;x<=max_n;x+=x&-x)sum[x]++;
}

int get_sum(int x){
  int ret = 0;
  while(x>0){
    ret += sum[x];
    x-=x&-x;
  }
  return ret;
}

int find(int x){
  return get_sum(max_n)-get_sum(x);
}

int main(){
  int n;
  scanf("%d",&n);
  max_n = 0;
  for(int i = 1; i<= n; ++i){
    scanf("%d",&a[i]);
    max_n = max(max_n,a[i]);
  }
  
  memset(sum,0,sizeof(sum));
  for(int i = 1; i<=n; ++i){
      int pos = find(a[i]);
      lt[i] = pos;
      add(a[i]);
  }
  
  vector<int> pos;
  memset(sum,0,sizeof(sum));
  for(int i = n; i>0; --i){
    int ps = find(a[i]);
    rt[i] = ps;
    add(a[i]);
    pos.push_back(i);
  }
  
  long long ans = 0;
  for(int idx = 0; idx < pos.size();++idx){
    int i = pos[idx];
    ans += min(lt[i],rt[i]);
  }
  cout<<ans<<endl;
}

 

H Colorful Tree

  • 给出一棵树，每个节点对应一种颜色。有m个询问，修改节点的颜色或者对于某一种颜色，包含这些颜色的子树有多少条边。

直接求每一种颜色的树的大小有一丢丢难（至少我没想到）。那么就只能一个一个的加到对应的颜色里面，算他的贡献了。

加入一个节点时，其他颜色的节点只有两种情况，要不在子树，要不在父亲，

如果所有点都在子树或者在父亲，那么就是到最远和最近的父亲或者子树u，贡献就是(dis(x,u)+dis(x,v)-dis(u,v))/2。

否则贡献为0，因为子树到父亲必定经过这个点。

这个两种其实可以合在一起，父亲是u，子树是v，那么贡献就是(dis(x,u)+dis(x,v)-dis(u,v))/2。

因此添加或者删除的时候通过dfs序找出最近的父亲(dfs序-1)或者子树(dfs序+1)，然后加上或者减掉贡献就好了。

 

using namespace std;
int mod = 998244353;
//int mod = 1e9+7;

vector<int> g[N];
int idx;
int dfn[N],dfn_c[N];
int c[N],num[N];
int fa[N][32], dp[N];
int n;

set<int> pos[N];

void dfs(int t, int f){
	dfn[t] = ++idx;
	dfn_c[idx] = t;
	fa[t][0] = f;
	dp[t] = dp[f]+1;
    for(int i = 1; i < 20; ++i){
      fa[t][i] = fa[fa[t][i-1]][i-1];
    }
	for(int u : g[t]){
		if(u==f)continue;
		dfs(u,t);
	}

}

int lca(int u, int v){
	if(dp[u] < dp[v]) swap(u,v);
	for(int i = 19; i >=0;--i){
		if(dp[fa[u][i]] >= dp[v]){
			u = fa[u][i];
		}
	}
	if(u==v) return u;
	for(int i = 19; i >=0;--i){
		if(fa[u][i]!=fa[v][i]){
			u = fa[u][i];
			v = fa[v][i];
		}
	}
	return fa[u][0];
}

int get_dis(int u, int v){
	int f = lca(u,v);
	return dp[u] + dp[v] - 2*dp[f];
}

int get_dis(int u, int v, int x){
	int dis1 = get_dis(u,x);
	int dis2 = get_dis(v,x);
	int dis3 = get_dis(u,v);
	return (dis1+dis2 - dis3)/2;
}

void change_dis(int idx, int flag){
    int col = c[idx];
    if(pos[col].empty()){
      num[col]=0;
      return;
    }
    auto r = pos[col].lower_bound(dfn[idx]);
    if(r==pos[col].begin() || r == pos[col].end()){
		auto l = pos[col].begin();
		auto r = pos[col].rbegin();
      num[col] += get_dis(dfn_c[*l], dfn_c[*r], idx) * flag;
    }
    else {
      auto l = r; --l;
      num[col] += get_dis(dfn_c[*l], dfn_c[*r], idx) * flag;
    }
}


void add(int idx, int flag){
	int col = c[idx];
	if(flag==1){
      change_dis(idx,flag);
	  pos[col].insert(dfn[idx]);
	}
	else {
      pos[col].erase(dfn[idx]);
      change_dis(idx,flag);
	}
}

int main(){
	clr(num);
	cin>>n;
	idx = 0;
	for(int i = 0; i < n-1; ++i){
		int a,b;
		cin>>a>>b;
		g[a].pb(b);
		g[b].pb(a);
	}
	dfs(1,0);

	for(int i = 1; i<=n; ++i){
		cin>>c[i];
		add(i,1);
	}

	int m;
	cin>>m;
	for(int i = 0; i < m; ++i){
		char op;
		int idx;
		cin>>op>>idx;
		if(op=='Q') {
			if(pos[idx].empty()) cout<<-1<<endl;
			else cout<<num[idx]<<endl;
		}
		else {
			int new_c;
			cin>>new_c;
			add(idx,-1);
			c[idx]=new_c;
			add(idx,1);
		}
	}
}

 

I Sixth Sense

  • 给出两个序列a,b。对b进行调整使得\sum (b[i]]>a[i])最大。如果有多个b，选字典序最大的。

 

最大值可以通过贪心。对于a[i],upper_bound出b。如果a是有序的话，b的结果是单调的。因此可以通过指针移动来解决。复杂度O（n）

然后在选择字典序最大时，枚举每一个a可以选择的b，然后去看剩下的a和b是否能满足条件。

枚举b需要二分，对比a大和比a小分别讨论，因此比a大贡献为1.

 

枚举时，先构造出可以用的a和b，这样时间就是O(n),在枚举加检查就是O(nlog(n))

总时间就是O(n^2log(n))

 

int n;
int p[N],f[N];
int vb[N];

int get_ans(vector<int>& a, vector<int>& b){
    int num = 0;
	int pos = 0;
    for(int i = 0; i < a.size(); ++i){
      while(pos<b.size()&&(vb[pos] || b[pos]<=a[i]))pos++;
      if(pos<b.size()){
        num++;
		pos++;
      }
    }

    return num;
}

int find(vector<int>&a, vector<int>&b, int s_idx, int e_idx, int tot){
	int l = s_idx, r = e_idx;
	while(l+1<r){
		int mid = (l+r)>>1;
		vb[mid]=1;
		int tmp = get_ans(a,b);
		if(tmp >= tot){
			l = mid;
		}
		else {
			r = mid;
		}
		vb[mid]=0;
	}
	return l;
}

int main(){
	cin>>n;
    vector<int> a,b;
    vector<pair<int,int>> pa;
	fr(i,0,n){
		cin>>p[i];
		pa.pb(mp(p[i],i));
	}
	fr(i,0,n){
		cin>>f[i];
        b.pb(f[i]);
	}

    sort(pa.begin(), pa.end());
	sort(b.begin(), b.end());

	for(int j = 0; j < pa.size();++j){
		a.pb(pa[j].first);
	}

	int tot = get_ans(a,b);
	vector<int> ans;
	fr(i,0,n){
        vector<int> a;
        for(int j = 0; j < pa.size();++j){
          if(pa[j].second<=i)continue;
          a.pb(pa[j].first);
        }
        vector<int> tmp;
        for(int j = 0; j < b.size();++j){
          if(vb[j])continue;
          tmp.pb(b[j]);
        }
        b = tmp;
        for(int j = 0; j < b.size();++j){
          vb[j] = 0;
        }
		int pos = upper_bound(b.begin(), b.end(), p[i])-b.begin();
		int ret = find(a,b,pos,b.size(),tot-1);
		if(ret!=b.size()){
			vb[ret]=1;
			if(get_ans(a,b)==tot-1){
				ans.pb(b[ret]);
				tot--;
				continue;
			}
			vb[ret]=0;
		}
		ret = find(a,b, 0,pos, tot);
		vb[ret]=1;
		ans.pb(b[ret]);
	}
	for(int x : ans)pf("%d ",x);
	pf("\n");
}

J Jokewithpermutation

  • 给出一个字符串，他是一个n的排列组成的串。还原他的排列。

暴力搜就好了。

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

int num[100];
string s;
int n;
vector<int> ans;
bool dfs(int idx){
  if(idx>=n){
    int max_v = 0;
    for(int i = 0; i < ans.size();++i){
    max_v = max(max_v, ans[i]);
    }
    for(int i = 1; i <=max_v; ++i){
      if(num[i]==0) return 0;
    }
    return 1;
  }
  int ret = 0;
  for(int i = 0; i < 2; ++i){
    ret = ret * 10 + s[idx+i]-'0';
    if(num[ret]==0){
      num[ret]=1;
      ans.push_back(ret);
      if(dfs(idx+i+1))return 1;
      num[ret]=0;
      ans.pop_back();
    }
  }
  return 0;
}

int main(){
  cin>>s;
  n = s.size();
  dfs(0);
  for(int x : ans) printf("%d ",x);printf("\n");
}

 

code到飞起
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
竞赛中的C++小方法汇总
swallowblank的博客
07-29 464
其实c++中有许多小方法，但是csdn就像一个巨大的垃圾库，你很容易搜到一些很垃圾的博客或代码。 1. C++ 结构体构造函数 struct node { int x,y,state,step; int hasRock; node(int a, int b, int c, int d, int e):x(a), y(b), state(c), step(d), hasRock(f){} } node start = node(0,0,0,0,0); ...
刷题总结#1
qq_26495925的博客
03-30 218
注意添加头文件#include 要用到sort，注意采用#include 对一个pair
牛客-Jokewithpermutation（dfs）
Cosmic_Tree的博客
10-24 212
题意 给你一串数字字符串，让你把他分开，分成 n 个数字(也就是 1 - n 都有)，n <= 50 。 思路 首先，我们根据字符串的长度可以确定 n 的值： 都是由一位数（ 1 - 9 ）组成的串，长度即为 n 值； 如果包含两位数， n = ( 长度 - 9 ) / 2 + 9 ； 然后，我们就 dfs 对串进行分割，每次可以割一个数字或者割两个数字（前提是这个割出来的数之前没有没割过（这里可以标记一下），同时不是 0 ，也不是 0 开头的，还不大于 50 ） 代码 #include<io.
2020牛客国庆集训派对day4 F
qq_37073764的博客
10-04 822
题目 对于每一个位置，统计一下它移到上升那边和下降那边分别需要多少次，然后贪心取个最小值，就可以了。 #include<cstdio> #include<algorithm> #include<cstring> #include<iostream> #include<vector> #include<cmath> #include<map> #include<string> #include<queue&
2020牛客国庆集训派对day4 补题
wxz0v0的博客
10-06 173
添加链接描述 补题B：本题求最长等差序列的长度 代码： #include<iostream> #include<cstdio> #include<cmath> #include<cstring> #include<string> #include<vector> #include<set> #include<vector> #include<queue> #include<stack> #
2020牛客国庆集训派对day1 A.ABB
旺崽的博客
10-02 2696
2020牛客国庆集训派对day1 A.ABB 题目链接 题目描述 Fernando was hired by the University of Waterloo to finish a development project the university started some time ago. Outside the campus, the university wanted to build its representative bungalow street for important fore
ABB (2020牛客国庆集训派对day1)
qq_35975367的博客
10-01 594
ABB 题意： 长度为n的字符串，问最少添加多少字符可以使其构成回文字符串 题解： 最长回文字符串我的第一反应是manacher马拉车算法，那我们直接马拉车找到已有最长回文串，然后总长度减去不就是答案吗？非也 ~ ~ 。注意是让我们构造最长回文字符串，我们会发现，如果我们用马拉车找到的最长回文串的最右端不是字符串最右端，那此情况就相当于作废 比如： murderforajarofz 我们可以找到最长回文串forajarof，但是最后一位z并不在里面，那你无论怎么构造也用不到forajarof这个回文串，也就
2020牛客国庆集训派对day3
扣脚老骚
10-03 186
2020牛客国庆集训派对day3 A Leftbest #include <bits/stdc++.h> //#define int ll using namespace std; #pragma GCC optimize(2) //#define int ll typedef long long ll; set<int > a; void solve() { ll sum=0; int n; cin>>n; for (int i =
2020牛客国庆集训派对day8
qq_35975367的博客
10-11 278
牛客网链接 文章目录Easy Chess题意：题解：Easy Problemset题意题解：Shuffle Cards题解：Diff-prime Pairs题意题解：代码： Easy Chess 题意： 通过n步从左下角走到右上角，每次移动都是直线，每个格子只能停留一下，输出停留过的格子 题解： 队友做的 #include<bits/stdc++.h> using namespace std; int n; bool vis[10][10]; int main(){ scanf("%d",&a
牛客国庆集训派对Day3 G（组合博弈）
yypurpose的博客
10-05 231
链接：https://www.nowcoder.com/acm/contest/203/G 来源：牛客网   Stones 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 524288K，其他语言1048576K 64bit IO Format: %lld 题目描述 有n堆石子，第i堆石子有xi个。 修修和栋栋轮流取石子，每人每次需要从任意一堆石子中取走个，修修先手。无法操...
2019牛客国庆集训派对day4 H：Highway（树形dp求树上最长路径）
菜鸡成长史
10-05 275
【题意】 给定一棵树，两个结点之间的距离为树上路径的长度，要求构造一棵树上所有边的权值和最大的树并输出权值。 【题解】 我们可以把这个问题转化成，求每个结点的树上最长路径再加入到新构造的树中，注意n个长度求和后要删去最长边，因为最长的路径被重复计数了而我们只需要n-1条边。 那么树上最长路径怎么求呢？ 可以看出，离第i个结点最远的距离，是边（v,i）的长度（其中v是i 的父亲）加上第v个...
牛客国庆集训派对Day4 E 乒乓球（组合计数 + NTT）
alpc_qleonardo
10-04 308
      求这个期望，无非就是要求一个贡献。而这个贡献就是任意间隔大于二的两个数字的乘积，然后统计它们的出现次数。 对于两个位置i和j，满足j&gt;i+1，现在考虑如何计算这个会出现的次数。我们令j-i-1=k，要做到会有wi*wj这个贡献，意味着从i和j中间k个乒乓球必须比第i和j个乒乓球先拿走。这个方案数我们这么考虑，首先着k个乒乓球可以任意排列，然后i和j两个放在它们后面，之...
牛客国庆集训派对Day3 B Tree（树形dp + 组合计数）
alpc_qleonardo
10-03 563
      题意有点绕，其实就是让你求一个点能被多少个点集包含，同时这些点集内的点要相互连通。 首先，简单来说，如果只是计算一个有根树中任意一个点被多少个只包含它以及它的子树的点的点集包含，那么直接普通的树上统计的trick就可以搞定。但是现在问题是，点集的点可以是其子树之外的点。我们注意到，对于根来说，它的答案都满足点集里面的点都在它的子树里面，所以说如果能够把每一个点都当作根来计算...
牛客国庆集训派对Day1 I Steins;Gate（原根 + FFT）
alpc_qleonardo
10-02 592
    上一次用到原根这个东西，应该是一年之前了吧…… 所谓原根，就是指对于某个数字P，满足它的原根g，g的0~P-2次幂在模P的意义下互不相同，或者说g的1~P-1次幂在模P的意义下无不相同。一般来说，原根只能够进行枚举求解，但是由于原根一般较小（2或者3），所以可以接受。 对于本题，要求对于每一个数字ak计算在模P意义下，有多少个ai*aj等于ak。直接做显然是O(N^2)的，不能...
ASP在线学习网站系统毕业课程源码设计+论文+英文翻译
最新发布
09-09
编号：94 (1)课堂学习模块 这个模块主要是提供给学习者学习内容，为静态内容。系统按各个科目分目录进行存放，并在菜单页面放置了链接。 该模块主要是为学生所使用，学习在登录系统后可直接选择进入本模块，通过对静态页面的浏览达到学习的目的。该功能设计应美观、便捷，使学生能够以一个较愉快的心情进行学习，以提高学习的效率。 另外教师发布的教案可能有各种形式，如htm、doc、ppt、avi等，但在通常情况下，这些教学内容都是静态内容，因此按类别及内容分类在网站上发布即可。 (2)作业模块 此模块为学生和教师共同使用，但根据权限的不同使用不同的功能。学生主要使用作业上传功能和查询作业分数功能，而教师主要使用网上下载作业并进行作业评分的功能。因此，系统需要提供以下功能： 上传：将作业上载到指定地点，并按某种方式进行标识。 批阅：教师可对作业进行批阅判分。 (3)在线答疑模块 网络课程的学习不同于一般的单机课件的学习，主要的一点在于学习环境的不同，它为学习者的学习交流、协作创造了条件，这是网络学习的一个优势。在线答疑主要是学习者和教师之间，学习者和学习者之间，就知识本身或相关话题的讨论。
基于ssm的中小企业人力资源管理系统的设计与实现.docx
09-09
基于ssm的中小企业人力资源管理系统的设计与实现.docx
springboot基于安卓的团购系统docx毕业论文.docx
09-09
springboot基于安卓的团购系统docx毕业论文.docx
基于ssm的端游账号销售管理系统设计与实现.docx
09-09
基于ssm的端游账号销售管理系统设计与实现.docx
2020牛客网名企校招技术笔试面试全攻略
"《牛客特制2020名企校招笔试面试求职攻略-技术篇》是一份专门为应届毕业生准备的求职宝典，由牛客网编撰，针对腾讯、字节跳动、华为、百度、网易、京东等27家知名互联网企业在2019年秋招中的笔试真题进行了详尽整理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值