XD

题目的意思是：n个数的集合，从中拿出两个数删掉，并将他们的和放入集合。要使最后的数最小很容易想到类似与Huffman编码，但是我们可以更简单的实现，用优先队列。下面的是AC的代码：#include #include #include using namespace std;int main(){ int n, x, i; while(cin >> n &

题目的意思是：n个村庄，每一个村庄可能需要买酒或者卖酒，ai 为负，则需要买 ai 个酒，ai 为正，则需要卖 ai 个酒，从一个村庄运k单位酒到邻村需要k个单位的劳动力。求最小劳动力。考虑最左边的村庄。如果需要买酒，即a1大于0，则一定有劳动力从村庄2往左运给村庄1，而不管这些酒是从哪里来的。这样，问题就等价于只有村庄2~n，且第2个村庄的需求为a1+a2的情形。ai #

分两边来枚举。减少时间复杂度。__int64在Uva上面用不了。。。代码很容易看懂。#include #include #include using namespace std;const int Maxn = 4005;int A[Maxn], B[Maxn], C[Maxn], D[Maxn];int AB[Maxn * Maxn];int main()

构造的题目，理解了题目的意思就很容易做。要你建一个大楼，有n个国家要在这里面办公，需要把格子分配给各个国家，任意两个国家都有一对相邻的格子（要么是相邻层的同一个格子，要么是同层中有公共边的格子）。只需构建两层的楼，第一层的第i列给第i个国家，第二层的第j行给第j个国家。构造出来的就符号题目的要求。AC的代码：#include using namespace std

题目的意思是：输入长度为N的序列，找到一个尽量长的连续子序列Ai~Aj，使得序列中没有重复的元素。可以用集合Set来求解。从0号位置开始，一直添加元素进去直到有重复，更新最长子序列的值，去掉最左边的元素，继续添加元素。不断的重复，更新。最终找到最大的子序列。下面的是AC的代码：#include #include #include #include using n

简单的题目，可以直接按照题目的意思模拟那个过程就可以过了。题目的意思：一叠煎饼在锅里，每个煎饼大小不一样，煎饼叠在一起的，每次选一个位置k，从顶部往下数k个反转过来，求出最后煎饼按小到大的方案。每次输出的是煎饼的总数减掉反转的位置。（煎饼从上到下，1~n）。从底部开始往上，每次将最大的弄到最下面来，（当前位置为 j ）每次选最大的，然后选个最大的，位置是k，判断是不是在最上边，

约瑟夫环问题。#include using namespace std;int a[14];int main(){ int n; a[1] = 2; for(int i = 2; i < 14; i++) { for(int m = i + 1; ; m++) { int s = 0, j = 2 * i; while(1) { i

简单的题目。求冒泡排序交换的次数。#include using namespace std;int data[60];int main(){ int n, l; cin >> n; while(n--) { cin >> l; for(int i = 0; i < l; i++) cin >> data[i]; int ans = 0; fo

求n！的质因子个数。也就是2~n每个数的质因子的个数之和。输出的格式比较麻烦，需要注意。代码：#include #include #include using namespace std;int vis[110], prime[100], count = 0;int ans[100];void prime_table() //获取质数表{ int i,

题目的意思求n个点连起来的最短距离。n最大为8，直接枚举排列的所以情况，然后求最短的距离，最短距离等于连线上的每两个点的距离加上16的和.点的排序可以多种情况，只要找到最短距离就行。枚举排列用next_permutation函数。代码：#include #include #include #include using namespace std;int n,

题目的意思：给你节点k，然后输入的是无向图，求1到节点k的所以路径。首先用Floyd算法算出两两之间的是否存在路径。然后在递归求出路径的时候可以很快的判断是否有路到达k节点。代码：#include #include using namespace std;const int maxn = 25;const int INF = 0xfffffff;int ma

题目的意思，无向图中求某个点到另外一个点的路径上的最大噪声值，最大噪声值比其他路径上的最大噪声值小，比该路径上的噪声大。最后问的是有q个问题，每个问题存入两个点，求这两点之间的最大噪声值，直接用Floyd算法。代码：#include #include using namespace std;const int INF = 0xfffffff;int c, s,

求有向图的传递闭包，并输出各个连通分量的成员。输出各个连通分量，可以递归输出。代码：#include #include #include #include #include using namespace std;const int maxn = 40;int n, m;vector vec;bool data[maxn][maxn], vis[ma

求的是倒水量最小，不是次数。代码：#include #include #include #include using namespace std;struct Node{ int v[3], dist; bool operator < (const Node& a)const { return dist > a.dist; }};const int

最小生成树的应用。输入n个城市（1~n），和q个方案，接下来q行的第一个数为该方案中的城市数a，第二个数为用该方案需要的钱b，接下来a个数为城市的编号。接下来n行为第n个城市所在的坐标位置。在这些城市之间建设道路，使得两两城市直接连通。在两个城市之间建设道路，需要花费 两个城市之间的坐标的欧几里德距离，若买方案，则方案内的城市已经连通。先进行一次求最小生成树，再枚举方案再求最小生成

这题，最小生成树的应用，只是需要稍微变形一下。输入结点数为n，边数为m，对每条边进行从小到大排序，然后枚举枚举每一条边，从该边起到最后这些边中求最小生成树并找到权值最大的边。不断的更新最大权值与枚举的边的差值。代码：#include #include using namespace std;const int maxn = 110;int m, n;

题目的意思，求矩阵的的子矩阵的最大和。暴力枚举行的组合，将各列数值相加，再查找最大连续和，更新最大值即可。代码：#include #include #include using namespace std;const int maxn = 110;int data[maxn][maxn], n;int main(){// freopen("1.txt

简单的回溯的应用。代码：#include #include #include using namespace std;int data[50], vis[50], n;int is_pre[50];void dfs(int x){ if(x == n && is_pre[data[0] + data[n - 1]]) { cout << data[0];

简单的题目，很容易看懂。主要是枚举，但是枚举的范围不确定。从x >= y , 推出 1 / x 然后就是枚举，暴力过。代码：#include #include #include using namespace std;int data[15000];int main(){// freopen("1.txt", "r", stdin); int k,

简单的题目，在N个数中找到差值最小的并且相加等于所给的 M。直接暴力枚举，数据量较小。代码：#include #include #include using namespace std;int data[10010];int n, money;int main(){// freopen("1.txt", "r", stdin); int i, j; w

暴力枚举，数据量相对较小。不过__int64 这个类型过不了。代码：#include #include using namespace std;int data[20];int n;long long Max, ans;int main(){// freopen("1.txt", "r", stdin); int i, j, t = 0; while(cin

简单的题目，暴力枚举可以过。只不过我第一次用的是五重循环枚举一直WR，2到79 的答案都对，就是不过，不知道为毛。。后来改用直接枚举其中一个数。代码：#include #include #include using namespace std;int ans[10];bool flag;int cheak(int x, int y){ memset(ans, 0

这题的意思：给你V个城市，两两城市有双向的通路，给你E个边，求最短路径走过这E个边。边长为T。一开始以为是BFS来求解，但是怎么都想不到切入口。后面看到欧拉两个字，恍然大悟，这题就是无向图的欧拉回路的求解。只不过，还需要判断图是否连通，存在多个连通图，需要将他们连通起来。然后判断各个节点的度，奇数的节点大于2，则需要加上 奇数点 / 2 - 1个边，才能使图存在欧拉回路。下面的代码

这题：找最短路径，只是可以跨越障碍，不能连续跨越K个障碍。可以通过BFS做。一开始我没有用vis数组，是在输入的矩阵中操作的，结果一直WR，不明白，为毛加了vis就可以，同样是标记的，自己还是有待提高。下面AC代码：#include #include #include using namespace std;struct node{ int x, y,

简单的BFS。只是国际象棋的棋盘有点特殊，坐标需要转换下。AC代码：#include #include #include using namespace std;struct node{ int x, y, count;};int xy[8][2] = {-1, -2, -2, -1, -2, 1, -1, 2, 1, 2, 2, 1, 2, -1, 1, -2};

根据先序遍历以及中序遍历，构造二叉树，输出后序遍历。代码：#include #include #include using namespace std;struct node{ char c; struct node *lchild, *rchild;};node *Root;int len;char pre[30], in[30];void crea

输入的第一行数字，是该满二叉树的叶子节点。接下来m行是查找叶子节点的数值的，0 向左走， 1 向右走。 用数组来表示二叉树。根节点为k，左孩子为2*k + 1，右孩子为2*k + 2。代码：#include #include #include using namespace std;char str[8][5];int num[300], ans[150

题目很简单，栈的应用。需要注意的是空串也是合法的。AC代码：#include #include #include #include using namespace std;int main(){// freopen("1.txt", "r", stdin); int n; bool ans; char str[140]; cin >> n; getchar

题目的意思：给你N个正方形，正方形每条边有编号，为一个大写字母加上一个“+”或者“-”，还有一个编号是“00”，“00”边不能连接其他的正方形，而想要连接需要字母相同，符号相反，问能不能无限的铺。下面是代码，有解析。主要是dfs来判断是否存在环。代码：#include #include using namespace std;int c[55];int G[55][55];

可以用DFS来做。找到子树的根，进行深搜。代码：#include #include #include #include using namespace std;const int maxn = 200 + 10;int n;char buf[maxn][maxn];void dfs(int x, int y){ cout << buf[x][y] <<

这题，可以转换成有向图的欧拉回路的判断。有向图的判断方法：所以点的入度等于出度或者有一个点的出度比入度大1有一个点的入度比出度大1，剩下的点入度等于出度。不过还有一个前提，就是图是连通的，可以用DFS来判断或者并查集。我用的是并查集。代码：#include #include using namespace std;struct node{ int indegre

简单的拓扑排序，模拟一下就可以了。AC代码：#include #include #include using namespace std;const int maxn = 110;int n, m;vector vec[maxn];int ans[maxn];bool cheak(){ for(int i = 1; i <= n; i++) if(!an

这题是2011年的World finals的题目。判断由01矩阵组成的图像是属于哪个古埃及的文字。从6个图形可以看出，每一个图形里面的  空洞  都是不同的。可以从空洞的个数来判断属于哪个文字。矩阵组成的每一个文字都是完整的，两个文字之间不会有连接。题目的给是01矩阵每四位构成的十六进制的矩阵，需要转换一下，这个不难。01矩阵外围再围上一圈 的 0，一开始进行一次深搜dfs（0

数油田的个数，简单的DFS。代码：#include #include using namespace std;const int maxn = 100 + 5;int num[maxn][maxn];char str[maxn][maxn];int m, n;void dfs(int x, int y){ if(num[x][y] != 0 || str[x][y]

#include #include #include using namespace std;const int len = 32;const int maxn = 1024 + 6;int buff[len][len], count;char s[maxn];void fun(char *str, int& pos, int r, int c, int w){ cha

输入的二叉树是先序遍历的形式，只是加上了各个叶子节点的左右孩子，都为-1.在递归的过程中算出水平位置的权值。（水平位置的权值，可以通过+1（右边节点）或者-1（左边节点） 来对应）代码：#include #include using namespace std;const int maxn = 10000 + 10;int sum[maxn];void build

判断天平是否平衡，W1 或 W2 为0，表示为子天平。递归过程中来输入并判断。代码：#include using namespace std;bool fun(int& n){ int a1, b1, a2, b2; bool a = true, b = true; //a表示左是否平衡，b表示右是否平衡 cin >> a1 >> b1 >> a2 >> b2;

这题主要是根据中序遍历和后序变量构造二叉树。一开始用 的是二叉树的数组表示形式来求解，但是本题的数据量挺大的，数组不能完全表示出来。关键点是这题的所有数都小于10000.所以用两个数组 lch 和rch 来表示权值点的左右孩子的情况。然后在通过dfs来查找叶子结点到根节点的最小权值的叶子。代码：#include #include #include #include usin

#include #include using namespace std;int main(){ int n; vector vec; while(cin >> n && n) { vec.clear(); for(int i = 1; i <= n; i++) vec.push_back(i); cout << "Discarded cards:"; i

#include #include #include using namespace std;int num[1005][20];int n, m;bool zero, loop;bool check(){ int i, j; for(i = 0; i < n; i++) { if(num[m][i] == 0) zero = true; else {