Ybibabo__-CSDN博客

原创 Mac安卓项目自动打包时报错xx.jks not found for signing config ‘release‘.

Mac Android Studio在app build.gradle.kts中设置好signingConfigs和applicationVariants，运行gradlew assemble报错如下：报错提示没有找到路径下的文件，排除了路径名、buildType写在signingconfig前面等错误后，发现去掉路径中的.jks即可成功运行。app gradle中的signingconfigs把storeFile路径名中.jks后缀删除......

2022-06-03 14:41:33 2058

原创 Android Studio从GitHub导入项目后显示add configuration，run按钮为灰色

解决方法选择项目中的build.gradle打开，等待Android Studio安装完相应依赖后即可运行

2022-05-06 14:56:43 3109

原创【天梯赛】L3-010 是否完全二叉搜索树

#include <bits/stdc++.h>using namespace std;const int N = 30;int n, tr[N];vector<int> level;void insert(int u, int x){ if(!tr[u]) { tr[u] = x; return; } if(x > tr[u]) insert(u * 2, x); else inser

2022-04-20 22:42:29 127

原创【天梯赛】L3-005 垃圾箱分布(堆优化版dijkstra)

与PAT甲级1072题加油站类似，坑点还是最后的结果需要加1e-8，1000个点可能不需要堆优化，朴素版dijkstra应该就可以，我用的堆优化版本是可以AC的。1072 Gas Station#include <bits/stdc++.h>using namespace std;typedef pair<int, int> PII;const int N = 999999, INF = 0x3f3f3f3f;int e[N], ne[N], h[N], idx, w

2022-04-20 21:42:46 256

原创【天梯赛】L2-012 关于堆的判断

主要考察的就是一个建堆的过程，小根堆比较简单，插入一个元素到树的末端，每次与他的父节点比较，如果插入的元素更小就swap该元素和父节点，再对更新后的父节点进行同样的操作直至递归到根节点，这个操作由up函数完成。#include <bits/stdc++.h>using namespace std;const int N = 1010;int n, m;int tr[N];unordered_map<int, int> mp;void up(int u){

2022-04-20 15:13:37 128

原创【PAT甲级】1072 Gas Station(Dijkstra、枚举)

#include <bits/stdc++.h>using namespace std;const int N = 1020;const int INF = 0x3f3f3f3f;int n, m, S, T, k, r;int g[N][N], dist[N];bool st[N];int get(string str){ if (str[0] == 'G') return n + stoi(str.substr(1)); return s

2022-04-16 20:51:52 196

原创【天梯赛】L3-028 森森旅游(堆优化的Dijkstra、multiset)

依然是dijkstra的模板，由于点数较多用的是堆优化版本的模板dist要开成long long，开int只能得20分#include <bits/stdc++.h>using namespace std;typedef long long LL;const LL INF = 0x3f3f3f3f3f3f3f3f;typedef pair<LL, int> PII;const int N = 100010 * 4;int n, m, S, T;int e[N],

2022-04-13 14:30:03 165

原创【天梯赛】L3-007 天梯地图（dijkstra单源最短路）

刷了天梯赛和PAT甲级里很多类似的题，都可以用dijkstra的模板解决，基本大同小异。模板来自于acwing y总，给给和我一样的新手同学推荐一下，要是我大一就能遇见y总就好啦T.T能少走很多弯路#include <bits/stdc++.h>using namespace std;const int N = 510;int n, m, S, T;int d1[N][N], dist1[N]; // timeint d2[N][N], dist2[N], sum[N]; //

2022-04-10 20:40:29 438

原创【PAT甲级】1087 All Roads Lead to Rome（dijkstra单源最短路）

还是dijkstra的模板题，这道题比较烦的是城市名是string，建图的话得要用一个哈希表映射一下城市名和数字下标的关系，输出答案时又要一个哈希表将下表映射回城市名。Tips：最短路数量最开始输出的一直是错误的结果，找了很久发现是dist相同时应该直接让cnt[j] += cnt[t]，距离相同时显然路线数量要加，与点权和及点数无关。#include <bits/stdc++.h>using namespace std;const int N = 510;int n, m, S,

2022-04-10 17:04:33 105

原创【PAT甲级】1101 Quick Sort（DP）

两个关键点：1：X是分界点的条件2：递推得到L[i]和R[i]#include <bits/stdc++.h>using namespace std;const int N = 100010, INF = 0x3f3f3f3f;int n, a[N];int l[N], r[N];int main(){ cin >> n; for(int i = 1; i <= n; i++) cin >> a[i]; for(int i = 1; .

2022-04-08 14:25:10 62

原创【PAT甲级】1007 Maximum Subsequence Sum（最大子序列和，动态规划）

动态规划，难点在于如何保证起始区间和终止区间最小。首先不考虑区间起止点，输出最大和。思路是一个简单的dp，分析与代码如下：#include <bits/stdc++.h>using namespace std;const int N = 10010;int w[N], f[N];int n;int maxF = -1;int main(){ cin >> n; for(int i = 1; i <= n; i++) cin >> w[i

2022-04-08 10:25:13 672

原创【PAT甲级】1030 Travel Plan（dijkstra单源最短路）

#include <bits/stdc++.h>using namespace std;const int N = 510;int n, m, S, T;int e[N][N], dist[N]; // ×î¶Ì¾àÀë int c[N][N], cost[N]; // ×îÉÙ»¨·Ñint pre[N]; // ¼ÇÂ¼Â·¾¶bool st[N]; void dijkstra(){ memset(dist, 0x3f, sizeof dist); memset(

2022-04-07 00:29:05 122

原创【PAT甲级】1003 Emergency（Dijkstra单源最短路）

#include <bits/stdc++.h>using namespace std;const int N = 510;int n, m, S, T;int e[N][N], w[N];int dist[N], cnt[N], sum[N];bool st[N];void dijkstra(){ memset(dist, 0x3f, sizeof dist); dist[S] = 0, cnt[S] = 1, sum[S] = w[S]; for(

2022-04-06 23:41:24 258

原创【PAT甲级】1155 Heap Paths（给定完全二叉树的层序遍历，判断是否为堆及堆的类型）

dfs每次插入一个当前点，检测到当前节点为叶子节点（u * 2 > n）时输出nodes中的全部元素，每次弹出nodes中的最后一个元素还原现场。判断类型用lt(less than)和gt(greater than)两个变量，每次输出nodes时顺带判断nodes当前元素较上一元素的变换情况。最后如果gt和lt都为true，说明路径的序列有递增也有递减，则不是堆，若只有gt为true，则说明路径是递增的，则为小根堆，否则为大根堆。#include <bits/stdc++.h>usi

2022-04-04 23:32:31 1324

原创【PAT甲级】1115 Counting Nodes in a BST（按序插入节点构造二叉树，输出最后两层的节点个数）

本题要点在于按照题目所给序列依次插入节点构造二叉树。构造二叉树采用l[x]和r[x]分别代表节点x的左右儿子的下标，若为0则说明该节点没有左/右儿子。以1号节点为根节点，每次插入都从根节点开始，权值小于等于当前节点则前往左子树，否则前往右子树，直至找到一个空节点插入权值。最后dfs遍历一下所有节点，cnt记录下每一层的节点个数，输出最后两层即可。需要注意的是insert函数中 int &u 实现了l[u]和r[u]的赋值。#include <bits/stdc++.h>usin

2022-04-03 15:08:21 933

原创【PAT甲级】1127 ZigZagging on a Tree（Z字形遍历二叉树）

此题是PAT甲级1020题的拓展，与1020唯一的不同就是输出的不再是层序遍历，而是Z字形遍历，依题意为右->左->右…的次序，在1020的基础上更改BFS函数，设置一个flag实现每隔一层翻转一次原本正常的层序遍历即可得到Z字形遍历。1020题代码：https://blog.csdn.net/qq_50985046/article/details/123809863?spm=1001.2014.3001.5502#include <bits/stdc++.h>using n

2022-04-03 13:25:49 930

原创【天梯赛】L1-079 天梯赛的善良（STL之multiset的应用）

#include <bits/stdc++.h>using namespace std;int n;multiset<int> s;int main(){ cin >> n; while(n --) { int t; cin >> t; s.insert(t); } cout << *s.begin() << ' ' <<

2022-03-31 18:03:28 503

原创【PAT甲级】1110 Complete Binary Tree（给定一棵树，判断是否为完全二叉树）

根节点赋予编号cur=1，遍历给定的二叉树，遍历的过程中左孩子编号2cur，右孩子编号2cur+1，记录下最大的编号，如果该编号与二叉树节点个数相同说明是完全二叉树，否则不是。#include <bits/stdc++.h>using namespace std;const int N = 30;int n;int l[N], r[N];bool hf[N];int maxCur = -1, nodeId;void dfs(int u, int cur){ if(

2022-03-30 23:30:34 141

原创【PAT甲级】1102 Invert a Binary Tree（反转二叉树）

二叉树构建好以后，中序遍历模拟一次，模拟时先走右子树再走左子树，即可得到反转后的中序遍历。再走一次BFS，BFS时同样先走右子树再走左子树，就是反转后的层序遍历。PS：也可以在构造二叉树时直接输入反转后的二叉树（先输入右子树再输入左子树），后面的DFS和BFS就不需要更改左右次序了。#include <bits/stdc++.h>using namespace std;const int N = 20;int n;int l[N], r[N];int in[N], level[

2022-03-30 22:47:47 739

原创【PAT甲级】1099 Build A Binary Search Tree（给定树结构构建二叉搜索树，并输出层序遍历序列）

本题与1064 Complete Binary Search Tree类似，区别在于完全二叉搜索树层序遍历可直接输出，本题是普通二叉搜索树，层序遍历需要一次bfs。#include <bits/stdc++.h>using namespace std;const int N = 110;int n;int l[N], r[N], tr[N], w[N];void dfs(int u, int &k){ if(l[u] != -1) dfs(l[u], k);

2022-03-29 22:51:44 60

原创【PAT甲级】1086 Tree Traversals Again

前序+中序求后序#include <bits/stdc++.h>using namespace std;const int N = 40;int n;vector<int> pre, in, post;void build(int il, int ir, int pl, int pr){ int root = pre[pl]; int k = il; while(k <= ir && in[k] != root) k++

2022-03-29 16:39:33 49

原创【PAT甲级】1064 Complete Binary Search Tree

1.二叉搜索树中序遍历是有序序列2.完全二叉树可由数组模拟，左子树为2n，右子树为2n+1#include <bits/stdc++.h>using namespace std;const int N = 1010;int n;int w[N], tr[N];int cnt;void dfs(int u){ if(2 * u <= n) dfs(2 * u); tr[u] = w[cnt ++]; if(2 * u + 1 <= n)

2022-03-29 16:05:18 1280

原创【PAT甲级】1021 Deepest Root（并查集求图的联通分量+dfs求最大深度）

遍历图中的每个节点，每次都将当前节点作为根节点求当前最大深度。#include <bits/stdc++.h>using namespace std;const int N = 10010, M = 2 * N;int n;int e[M], ne[M], h[N], idx;int f[N];int maxDepth = -1;void add(int a, int b){ e[idx] = b, ne[idx] = h[a], h[a] = idx++;}

2022-03-29 11:23:22 78

原创【PAT甲级】1020 Tree Traversals（已知树的中序+后序遍历输出层序遍历）

#include <bits/stdc++.h>using namespace std;const int N = 40;int n;int post[N], in[N];unordered_map<int, int> l, r, pos;vector<int> res;int buildTree(int il, int ir, int pl, int pr){ int root = post[pr]; int k = pos[roo

2022-03-28 23:47:22 294

原创【PAT甲级】1004 Counting Leaves（DFS求树每一层叶子节点的个数）

#include <bits/stdc++.h>using namespace std;const int N = 110;int e[N], ne[N], idx, h[N];int n, m;int cnt[N], max_depth = -1;void add(int a, int b){ e[idx] = b, ne[idx] = h[a], h[a] = idx++;}void dfs(int u, int depth){ if(h[u] ==

2022-03-28 22:46:14 76

原创 L2-022 重排链表

#include <iostream>#include <vector>using namespace std;const int N = 100010;int n;int e[N], ne[N], h;int main(){ cin >> h >> n; for(int i = 0; i < n; i ++) { int add, data, next; cin >&gt

2022-03-23 20:14:56 1230

原创 L2-002 链表去重

#include <iostream>#include <vector>using namespace std;const int N = 100010;int n;int e[N], ne[N], h;bool st[N];vector<int> a, b;int main(){ cin >> h >> n; while(n --) { int add, data, next;

2022-03-23 20:13:41 1506

原创【PAT乙级】1110 区块反转

#include <bits/stdc++.h>using namespace std;const int N = 100010;int e[N], ne[N];int n, h, k;int main(){ cin >> h >> n >> k; while(n --) { int add, data, next; cin >> add >> data >

2022-03-23 20:11:21 214

原创【PAT甲级】1074 Reversing Linked List

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.Input Specification:Each

2022-03-23 20:09:21 55

原创 L3-011 直捣黄龙（Dijkstra模板）

和L2-001几乎一模一样。。。套模板完事#include <iostream>#include <cstring>#include <unordered_map>#include <vector>using namespace std;const int N = 210;int n, m, S, T;string s, t;int e[N][N], dist[N], cnt[N];int total[N]; // 总城市数int w

2022-03-10 23:33:10 205

原创 L2-040 哲哲打游戏（模拟题）

很简单的一道题，但是看不懂题目意思卡了很久。其实就是邻接表存下各个剧情点之间的关系后，操作0就是前往当前剧情点能去的第j条路.#include <iostream>#include <vector>using namespace std;const int N = 100010;int n, m;int cd[N];int res = 1;vector<int> e[N];int main(){ cin >> n >&g

2022-03-10 17:33:48 4243

原创 L3-008喊山（BFS模板的应用）

#include <iostream>#include <queue>#include <cstring>using namespace std;const int N = 10010 * 2;int n, m, k;int e[N], ne[N], idx, h[N];int level[N];bool st[N];void add(int a, int b){ e[idx] = b, ne[idx] = h[a], h[a] = idx

2022-03-07 11:57:32 154

原创 L2-026 小字辈（BFS模板的应用）

#include <iostream>#include <cstring>#include <queue>#include <vector>using namespace std;const int N = 100010;int n;int e[N], ne[N], idx, h[N];int level[N];int maxlevel = -1;void add(int a, int b){ e[idx] = b, ne[idx

2022-03-06 11:29:04 173

原创 L2-001 紧急救援（单源最短路，dijkstra模板题）

#include <iostream>#include <cstring>#include <vector>using namespace std;const int N = 510;int n, m, S, T;int dist[N], g[N][N];bool st[N];int pre[N], w[N], sum[N], cnt[N];vector<int> ans;void dijkstra(){ memset(di

2022-03-05 18:57:01 221

原创天梯赛L2-013红色警报（并查集计算图的连通分量）

#include <iostream>using namespace std;const int N = 510, M = 5010;int n, m;int f[N];struct edge{ int a, b;}e[M];int find(int x){ if(f[x] != x) f[x] = find(f[x]); return f[x];}int main(){ cin >> n >> m; f

2022-03-01 14:29:13 162

转载 Kaggle笔记K-折交叉验证

k-折交叉验证转自：https://zhuanlan.zhihu.com/p/106375583https://zhuanlan.zhihu.com/p/85855015import gcX=trainX_test=testdel traindel testgc.collect()from sklearn.model_selection import StratifiedKFoldimport lightgbm as lgbparams = {'num_leaves': 491,

2021-11-11 14:46:18 276 2

原创任意参赛人数的循环赛日程问题（非分治方法，找规律解决）

算法课的作业，问题如下：和书上的问题有所不同，书上人数只能是2^k人，而作业中的题目要求为n人。书上的分治法很好理解，矩阵左上移到右下，左下移到右上就可以解决问题，但扩展到奇数人时就不适用了，查询网上的代码也很难理解，在查询资料过程中看到了一篇研究该问题的论文，是采用找规律的方法，不含任何算法上的技巧，比较朴实无华，但是我觉得很有意思，就按照他的思路自己编写了代码完成此次作业。具体如下思路：假设有N名选手参赛，我们首先构造一个N×N的矩阵。在矩阵第一行填充1，2,…,N，第一列填充1，2,…,N。这样

2021-11-05 12:03:06 399

空空如也

空空如也