谷歌中国算法比赛解题报告 APAC2016C

最新推荐文章于 2023-05-23 21:03:17 发布
最新推荐文章于 2023-05-23 21:03:17 发布
阅读量580 收藏
点赞数
分类专栏： APAC 文章标签： APAC google 算法 解题报告 谷歌中国
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaopt006/article/details/53052870
版权

Problem A. gRanks

Problem B. gFiles

Problem C. gGames

Problem D. gMatrix


1. 这个题，思路很直接，把每个人的得分算一下，然后相同的，按字母表排序输出（其实直接往map里插就好了，自动排序号）。记得名次要稍微注意下，就没了。


2. 这个题根据算式是可以算出上下限的，然后不断收缩上下限，看能不能确定唯一的数量，要注意的是，如果进度是100%就直接输出！


3. 这个题如果能想出关键的一步减枝，就不难了，否则非常难。。。

正确思路如下：

先建立一个树状结构，毕竟题目最多也就16个叶子节点。

然后放顺序，如果不减枝，小数据有8！种序列，大数据有16！种序列。

暴力是可以做小数据的

对于大数据，因为数字是从左往右放的，所以一个数字如果放在右枝，并且左枝是空的话，说明这个数字之前放过左枝，而现在把这个数字放在右枝是一种重复

同理，如果一个数字放在左枝，往上找父亲，如果父亲是右枝，并且左枝是空的话，说明这个数字之前已经放过了，重复，所以不放这个数字，如果父亲是左枝，就再往上找。

综合，放一个数字进叶子时，如果叶子是右枝且左枝为空就不放，否则对这个叶子节点的父亲做同样的检测。。。重复这个过程，就形成了最关键的一步减枝！

为什么是对的，做完这道题就明白了。。。（lz也是忽然脑洞大开）


4.

这个最后一题其实挺简单，真应该和第三题换换……

基本思想就是建立一个新的矩阵，最终让这个矩阵的每个节点存储以这个节点为左上角的正方形的最大值。

具体先一列列的压缩，再一行行的压缩。 比如

11 11 24

13 13 26

14 14 27

先压缩成

13 13 26

14 14 27

再压缩成

13 26

14 27

求和等于80

具体看了代码就明白了，非常好理解……

当然，不一定是最优的，lz没有去看高手是怎么做的


最后，附上代码

#include <stdio.h>
#include <iostream>
#include <fstream>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <hash_map>
#include <hash_set>
#include <unordered_map>
#include <unordered_set>
#include <string.h>
#include <queue>
#include <list>
#include <iomanip>

using namespace std;

#define ll long long


class PA
{
public:
	PA(){}
	int P, M, N;
	vector<int> points;
	struct competition
	{
		int ratio;
		vector<string> players;
		competition(){ ratio = 0; }
	};

	vector<competition> competitions;
	map<string, vector<int>> playerScores;



	void SingleProcess(ofstream& fout)
	{
		playerScores.clear();
		for (int i = 0; i < competitions.size(); i++)
		{
			for (int j = 0; j < competitions[i].players.size(); j++)
			{
				playerScores[competitions[i].players[j]].push_back(competitions[i].ratio*points[j]);
			}
		}

		map<int, map<string, int>> ranks;
		for (map<string, vector<int>>::iterator iter = playerScores.begin(); iter != playerScores.end(); iter++)
		{
			int totalScore = 0;
			sort(iter->second.begin(), iter->second.end());
			reverse(iter->second.begin(), iter->second.end());
			
			for (int i = 0; i<iter->second.size()&&i<M;i++)
			{
				totalScore += iter->second[i];
			}
			ranks[totalScore][iter->first] = 1;
		}

		int count = 1;
		int rank = 1;
		
		map<int, map<string, int>>::iterator iter = ranks.end();
		iter--;
		for (; iter != ranks.end(); iter--)
		{
			for (map<string, int>::iterator it2 = iter->second.begin(); it2 != iter->second.end(); it2++)
			{
				fout << "\n" << rank << ": " << it2->first.c_str();
				count++;
			}
			rank = count;
		}

	}

	void run()
	{
		FILE* fp = freopen("in.txt", "r", stdin);
		ofstream fout("out.txt");
		int Cases = 0;
		scanf("%d", &Cases);
		for (int time = 0; time < Cases; time++)
		{
			scanf("%d", &P);
			points.resize(P, 0);
			for (int i = 0; i < P; i++)
			{
				scanf("%d", &points[i]);
			}

			scanf("%d", &N);
			competitions.clear();
			competitions.resize(N, competition());
			for (int i = 0; i < N; i++)
			{
				competitions[i].players.resize(P, "");
				scanf("%d", &competitions[i].ratio);
				char ch[256];
				for (int j = 0; j < P; j++)
				{
					scanf("%s", ch);
					competitions[i].players[j] = ch;
				}
			}

			scanf("%d", &M);

			fout << "Case #" << (time + 1) << ": ";
			SingleProcess(fout);
			fout << endl;
			std::cout << time << endl;
		}
		fclose(fp);
		fout.close();
	}
};

class PB
{
public:
	PB(){}
	int N;
	vector<vector<ll>> lines;

	void SingleProcess(ofstream& fout)
	{
		ll total;
		ll upper, lower;
		upper = 0x7fffffffffffffff;
		lower = 0;

		for (int i = 0; i < lines.size(); i++)
		{
			ll ct = lines[i][1] * 100;
			ll cp = lines[i][0];
			//没有101，注意
			if (cp == 100)
			{
				fout << ct / 100;
				return;
			}
			if (cp != 0)
			{
				if (ct%cp == 0) upper = min(upper, ct / cp);
				else upper = min(upper, ct / cp);
			}

			
			cp++;
			if (ct%cp == 0) lower = max(lower, ct / cp + 1);
			else lower = max(lower, ct / cp + 1);
		}

		if (lower == upper) fout << lower;
		else fout << -1;
	}

	void run()
	{
		FILE* fp = freopen("in.txt", "r", stdin);
		ofstream fout("out.txt");
		int Cases = 0;
		scanf("%d", &Cases);
		for (int time = 0; time < Cases; time++)
		{
			scanf("%d", &N);
			lines.resize(N, vector<ll>(2, 0));
			for (int i = 0; i < N; i++)
			{
				scanf("%lld %lld", &lines[i][0], &lines[i][1]);
			}

			fout << "Case #" << (time + 1) << ": ";
			SingleProcess(fout);
			fout << endl;
			std::cout << time << endl;
		}
		fclose(fp);
		fout.close();
	}
};

class PC
{
public:
	PC(){}
	int N, M;
	struct Elf
	{
		int id;
		vector<int> friends;
		int round;
		Elf()
		{
			id = -1;
			round = 0;
			friends.clear();
		}
	};

	Elf elfs[16];

	struct TreeNode
	{
		TreeNode* parent;
		TreeNode* leftChild;
		TreeNode* rightChild;
		vector<int> ids;
		int round;
		TreeNode()
		{
			parent = leftChild = rightChild = 0;
			round = 0;
			ids.clear();
		}
	};

	TreeNode leafs[16];
	TreeNode* head;

	void BuildTree()
	{
		queue<TreeNode*> levels;
		for (int i = 0; i < 16; i++)
		{
			levels.push(&leafs[i]);
		}
		int total = levels.size();
		int current = 0;
		while (levels.size()>1)
		{
			TreeNode* tn = new TreeNode();
			tn->leftChild = levels.front();
			levels.front()->parent = tn;
			levels.pop();
			tn->rightChild = levels.front();
			tn->round = levels.front()->round + 1;
			levels.front()->parent = tn;
			levels.pop();
			levels.push(tn);
		}
	}

	void resetTree(TreeNode* tn)
	{
		tn->ids.clear();
		if (tn->leftChild) resetTree(tn->leftChild);
		if (tn->rightChild) resetTree(tn->rightChild);
	}

	bool isFriend(Elf *e, int id2)
	{
		for (int i = 0; i < e->friends.size(); i++)
		{
			if (e->friends[i] == id2) return true;
		}
		return false;
	}

	bool checkConflict(vector<int>& vec, int t, int round)
	{
		Elf* e = &elfs[t];
		for (int i = 0; i < vec.size(); i++)
		{
			Elf* e2 = &elfs[vec[i]];
			if ((e->round >= round&&isFriend(e, e2->id)) || (e2->round >= round&&isFriend(e2, e->id)))
			{
				return true;
			}
		}
		return false;
	}

	bool findone = false;

	void DFS(int depth)
	{
		if (findone) return;
		/*for (int i = 0; i < N; i++)
		{
		if (leafs[i].ids.size() == 0) printf("%d ", 0);
		else printf("%d ", leafs[i].ids[0]+1);
		}
		printf("\n");*/
		if (depth == N)
		{
			findone = true;
			return;
		}

		for (int i = 0; i < N; i++)
		{
			if (findone) return;
			TreeNode* t = &leafs[i];
			if (t->ids.size()>0) continue;
			while (t != head&&t == t->parent->leftChild)
			{
				t = t->parent;
			}
			if (t != head&&t->parent->ids.size() == 0) continue;

			t = &leafs[i];
			bool conf = false;
			while (t != head->parent)
			{
				if (checkConflict(t->ids, depth, t->round))
				{
					conf = true;
					break;
				}
				t = t->parent;
			}
			if (conf) continue;

			t = &leafs[i];
			while (t != head->parent)
			{
				t->ids.push_back(depth);
				t = t->parent;
			}

			DFS(depth + 1);

			t = &leafs[i];
			while (t != head->parent)
			{
				t->ids.pop_back();
				t = t->parent;
			}
		}
	}

	string SingleProcess()
	{
		findone = false;
		DFS(0);
		if (findone) return "YES";
		return "NO";
	}

	void run()
	{
		FILE* fp = freopen("in.txt", "r", stdin);
		ofstream fout("out.txt");
		int Cases = 0;
		scanf("%d", &Cases);
		BuildTree();

		for (int time = 0; time < Cases; time++)
		{
			scanf("%d %d", &N, &M);
			head = &leafs[0];
			for (int i = 0; i < N; i++)
			{
				head = head->parent;
			}
			resetTree(head);
			N = pow(2, N);
			for (int i = 0; i < N; i++)
			{
				elfs[i].friends.clear();
				elfs[i].id = i;
				elfs[i].round = 0;
			}
			for (int i = 0; i < M; i++)
			{
				int e, k, b;
				scanf("%d %d %d", &e, &k, &b);
				elfs[e - 1].friends.resize(b, 0);
				elfs[e - 1].round = k;
				for (int j = 0; j < b; j++)
				{
					scanf("%d", &elfs[e - 1].friends[j]);
					elfs[e - 1].friends[j]--;
				}
			}


			fout << "Case #" << (time + 1) << ": " << SingleProcess().c_str() << endl;
			cout << time << endl;
		}
		fclose(fp);
		fout.close();
	}
};

class PD
{
public:
	PD(){}
	int N, K, C, X;
	vector<vector<int>> matrix;
	void SingleProcess(ofstream& fout)
	{
		vector<vector<int>> k_matrix(N, vector<int>(N, 0));
		map<int,int> smap;
		map<int, int>::iterator iter;
		//竖着刷
		for (int col = 0; col < N; col++)
		{
			smap.clear();
			for (int row = 0; row < N; row++)
			{
				if (row < K-1) smap[matrix[row][col]]++;
				else
				{
					smap[matrix[row][col]]++;
					k_matrix[row + 1 - K][col] = smap.rbegin()->first;
					iter = smap.find(matrix[row + 1 - K][col]);
					iter->second--;
					if (iter->second == 0) smap.erase(iter);
				}
			}
		}

		//横着刷
		for (int row = 0; row < N - K + 1; row++)
		{
			smap.clear();
			for (int col = 0; col < N; col++)
			{
				if (col < K-1) smap[k_matrix[row][col]]++;
				else
				{
					smap[k_matrix[row][col]]++;
					int temp = k_matrix[row][col + 1 - K];
					k_matrix[row][col + 1 - K] = smap.rbegin()->first;
					iter = smap.find(temp);
					iter->second--;
					if (iter->second == 0) smap.erase(iter);
				}
			}
		}

		ll ret = 0;
		int NK = N - K + 1;
		for (int i = 0; i < NK; i++)
		{
			for (int j = 0; j < NK; j++)
			{
				ret += k_matrix[i][j];
			}
		}
		fout << ret;
	}

	void run()
	{
		FILE* fp = freopen("in.txt", "r", stdin);
		ofstream fout("out.txt");
		int Cases = 0;
		scanf("%d", &Cases);
		for (int time = 0; time < Cases; time++)
		{
			scanf("%d %d %d %d", &N, &K, &C, &X);
			vector<int> arrayA, arrayB;
			arrayA.resize(N, 0);
			arrayB.resize(N, 0);
			matrix.clear();
			matrix.resize(N, vector<int>(N, 0));
			for (int i = 0; i < N; i++)
			{
				scanf("%d", &arrayA[i]);
			}
			for (int i = 0; i < N; i++)
			{
				scanf("%d", &arrayB[i]);
			}

			for (int i = 0; i < N; i++)
			{
				for (int j = 0; j < N; j++)
				{
					matrix[i][j] = (arrayA[i] * (i + 1) + arrayB[j] * (j + 1) + C) % X;
				}
			}

			fout << "Case #" << (time + 1) << ": ";
			SingleProcess(fout);
			fout << endl;
			std::cout << time << endl;
		}
		fclose(fp);
		fout.close();
	}
};





int main()
{
	//PA p;
	//PB p;
	PC p;
	//PD p;
	p.run();

	return 0;
}


zhaopt006
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
google算法编程大赛.zip
06-09
google算法编程大赛.zip
谷歌中国算法比赛解题报告 APAC2016A
zhaopt006的博客
11-06 727
Problem A. Googol String Problem B. gCube Problem C. gCampus Problem D. gSnake 1. 这题不要被10的100次方吓到了，其实这题思路很简单，注意长度上S2=S1*2+1，所以先找到第k个数字属于S几，然后倒着找，如果数字在倒着的左串就不改变，在右串就等于左串对应位置的数字改变（0变1,1变0）
一道 Google 竞赛题的解法
Ackarlix的专栏
08-30 1496
 一道 Google 竞赛题的解法一、竞赛题目Problem Statement You are given a String[] grid representing a rectangular grid of letters. You are also given a String find, a word you are to find within the g
Google为改善其视频分析算法举办大奖赛
bingyu1024的博客
05-23 62
现在谷歌为此计划带来重大更新，除了加入更多视频标签和音频元素外，他们更在 Kaggle 社交发起奖金总值达 100,000 美元的竞赛，吸引各路编程好手能设计最好的算法来为 700,000 套视频加入标签（用于训练的 8M 数据组数目）。胜出者名单将会在 7 月在 IEEE 会议上的 YouTube-8M Workshop 中公布，最佳队伍能获得 30,000 美元，所谓重赏之下、必有勇夫，相信能吸引不少身怀绝技的团队参赛。编辑：张宏宇，审核员：逄增宝。
2016C-report-邵韵秋1
08-08
这篇作业是关于计算机网络安全技术的，主要涵盖了网络配置、路由器接口设置、IP地址、子网掩码、网关配置、路由协议以及密码安全等方面的知识。以下是这些知识点的详细说明： 1. **网络配置**：网络配置涉及到IP...
2024嵌入式面试资料搜狗2016C++工程师笔试题及答案
最新发布
06-09
2024嵌入式面试资料搜狗2016 C++工程师笔试题及答案提取方式是百度网盘分享地址
dicom3.0 2016c(英文)
07-26
DICOM is managed by the Medical Imaging & Technology Alliance - a division of NEMA DICOM consists of the following parts: • PS3.1: Introduction and Overview (this document) • PS3.2: Conformance ...
网页游戏设计基础 考试题2016C1 参考答案及评分标准.docx
06-30
【网页游戏设计基础】课程考试主要考察学生对网页制作基础知识的理解和应用，涵盖HTML、CSS和JavaScript等核心技术。以下是对试卷内容的详细解析： ...这些知识点是构建网页的基础，理解每个标签的作用对于网页布局至...
YLMF_GHOST_WIN7_SP1_X86_ULTIMATE_2016C1.part4.rar
12-28
YLMF_GHOST_WIN7_SP1_X86_ULTIMATE_2016C1.part4.rar
APAC 算法：一个 Matlab 函数文件计算无向图任意两个节点之间的所有路径-matlab开发
06-01
该函数旨在实现 Ricardo Simões 在他在 Revista de Estudos Politécnicos，Polytechnical Studies Review，2009，Vol VII，nº12，039-055 中的研究贡献中提出的 APAC 算法。 此代码已从算法中修改，以便获得随机连接的无向图的任意两个节点之间的所有路径，而无需查找循环。 这是我的研究工作的要求，即不需要循环。 所以 APAC 算法被修改为只计算路径。
谷歌中国算法比赛解题报告 APAC2017B
zhaopt006的博客
11-06 296
Problem A. Sherlock and Parentheses Problem B. Sherlock and Watson Gym Secrets Problem C. Watson and Intervals Problem D. Sherlock and Permutation Sorting 好吧，lz还是没时间好好做完做这四道题……2017
谷歌中国算法比赛解题报告 APAC2015D
zhaopt006的博客
11-06 423
Problem A. Cube IV Problem B. GBus count Problem C. Sort a scrambled itinerary Problem D. Itz Chess 作为2015年的最后一场APAC,谷歌你真的打算在这场比赛里招人么？？？？？ 这四道题都毫无难度可言，而且最后一题，对从没玩过国际象棋的我……你的描述不清晰，
谷歌中国算法比赛解题报告 APAC2017A
zhaopt006的博客
11-06 751
Problem A. Country Leader Problem B. Rain Problem C. Jane's Flower Shop Problem D. Clash Royale 终于来到APAC2017了，lz作为一个找工作之前从没刷过题的研究僧，心情真是极为复杂，不过现在已经在某知名公司找到了游戏程序的工作，终于能正视这些题了，说实话，我也不
谷歌中国算法比赛解题报告 APAC2015C
zhaopt006的博客
11-06 324
Problem A. Minesweeper Problem B. Taking Metro Problem C. Broken Calculator Problem D. Tetris 这次的题侧重考工程了，其实每道题都不算难，就是麻烦…… 1.扫雷，这道题思路很简单，首先把空白都点了，因为空白会打开周围8个格子，当没有空白可点的时候，再把没有点开的格子
Google编程大赛入围赛750分真题
陈亚平 的技术博客
12-13 6846
Google编程大赛入围赛750分真题   第五组Problem Statement牋牋You are given a String[] grid representing a rectangular grid of letters. You are also given a String find, a word you are to find within the grid. The star
google排名算法，公式
编程之路
02-24 4368
学习了一段时间大概知道些SEO常识，但是具体每一项的影响有多少自己并不清楚，对自己来说是个谜，今天偶然看到2010年google排名算法，觉得对自己很有帮助，感觉清晰多了。虽然百度文库里都有，发出来，看看对大家有没有帮助。至少有所了解，虽然各项权重会发生变化，但是基本内容是万变不离其中。 Google排名算法公式（原文）： 　　GoogleScore = (KW Usage Score * 0.
Google编程大赛入围赛750分真题(第五组) 之解法
RoadNorth的专栏
12-16 9840
在CSDN首页看到Google编程大赛入围赛750分真题   第五组之后，一时手痒，动手用C++做了一个解决方案，写出来接受大家的批评，呵呵。先贴上代码，=============================================================================#pragma warning (disable : 4786)#include #incl
高手过招 放“码”出击 | 2022 Google 全球编程比赛集结倒计时！
谷歌开发者
02-24 667
2022 Google 全球编程系列比赛邀你来挑战！牛刀小试 层层闯关巅峰角逐 高手过招齐齐报名 放“码”出击马上报名的四大理由钻研能力近距离巅峰较量， 与世界高手同场竞技，提升自己的编...
"知识图谱中的语义关联挖掘研究：基于链接模式的高效算法与语义关联检索模型
近年来，在语义关联挖掘领域[Zhang2012, Zhao2012, Wang2013b, Zhang2016a, Zhang2016c]、语义推理领域[Ma2011, Ma2013, Ma2014, Zhou2015, Zhou2016a, Zhou2016b, Jabbour2016]、语义数据摘要领域[Zhang2007, Zhang...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值