Google APAC Round D题解

Problem A. Dynamic Grid

最基础的搜索，我用DFS做的，标记棋盘上每一个位置初始化为未搜索，遍历整个棋盘，如果遇到1且以前从没搜索到的话就从该点开始不停搜索，直到搜完，复杂度O(m*n)

代码

int m, n;
int q;
char b[110][110];
bool flag[110][110];
bool valid(int x ,int y)
{
if(x < 0 || x >= m)
return false;
if(y < 0 || y >= n)
return false;
if(flag[x][y] == 1)
return false;
if(b[x][y] != '1')
return false;
return true;
}
void DFS(int x ,int y)
{
flag[x][y] = 1;
if(valid(x - 1, y))
DFS(x - 1, y);
if(valid(x + 1, y))
DFS(x + 1, y);
if(valid(x, y - 1))
DFS(x, y -1);
if(valid(x, y + 1))
DFS(x, y + 1);
}
int solve()
{
ZERO(flag);
int count = 0;
FOR(i,0,m)
FOR(j,0,n)
{
if(b[i][j] == '1' && flag[i][j] == false)
{
DFS(i,j);
count++;
}
}
return count;
}
int main(){
int Tcase;
cin >> Tcase;

FOR(hh,0,Tcase)
{
cin >> m >> n;
FOR(i,0,m)
FOR(j,0,n)
cin >> b[i][j];
cin >> q;
cout << "Case #" << hh + 1 << ":" << endl;
char ops;
FOR(i,0,q)
{
cin >> ops;
if(ops == 'Q')
cout << solve() << endl;
else
{
int x ,y;
char val;
cin >> x >> y >> val;
b[x][y] = val;
}
}
}

return 0;
}

Problem B. gBalloon

很有意思的题目，首先考虑不可能的情况：

1.如果风向和距离的乘积为正数或者0（距离不为0），那么一定需要移动这个气球（称之为坏球），记下所需要的最小的消耗，如果所有坏球所需最小消耗的和大于q，那么不可能。

2.考虑如果需要移动气球，那么肯定是在时刻0的时候移动，我们用set维护一个3-element entry记录（当前气球标号，该球消耗的能量，到达0位置所需要的时间），并按最后一项的值从大向小排序。初始化时所有好球消耗的能量为0，时间根据dis/v向上取整。所有坏球计算所需最小的消耗和时间。每次从set中拿出第一位的项（时间最长），因为是它限制了最后到达的时间，给他能量看能否快过第二项，如果在当前能量+之前消耗的 可以保证他快过第二项，那么更新该项并且重新插入，同时更新剩余的能量。如果不能的话则循环结束，将所有的剩余能量尝试更新最开始的项，返回该项所需的时间。

因为每次消耗的q会最少增加1，所以总得复杂度是O(q * m * logn)

#define FOR(a, b, n) for(int (a) = (b); (a) < (n); ++(a))
#define ITE(a, v) for(auto (a) = v.begin(); (a) != v.end(); ++(a))
#define LL long long
#define ALL(v) v.begin(),v.end()
#define ZERO(v) memset(v, 0, sizeof v)
#define NEG(v)  memset(v, -1, sizeof v)
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define MOD 1000000007
#define PI 3.141592653589793
inline long double min(long double a , long double b) {if(a < b)return a; return b;}
inline long double max(long double a , long double b) {if(a < b)return b; return a;}

int m, n;
int q;
int speed[1100];
pair<int,int> pos[110];

set<pair<int,int>,greater<pair<int,int> > > uset;
int calc(int p, int s)
{
if(p * s >= 0)
return INT_MAX;
int t = p / s;
if(t * s == p)
return abs(t);
else
return abs(t) + 1;
}
int solve()
{
int sum = 0;
int flag[110];
int energy[110];
ZERO(energy);
ZERO(flag);
FOR(i,0,n)
{
if(pos[i].first == 0)
continue;
int p = pos[i].first;
int h = pos[i].second;
if(speed[h] * p == 0 || speed[h] * p > 0)
{
flag[i] = 1;
}
else
{
int t = p / speed[h];
if(t * speed[h] == p)
uset.insert(MP(abs(t),i));
else
uset.insert(MP(abs(t) + 1, i));
}
}
int eng = 0;
FOR(i,0,n)
{
if(!flag[i])
continue;
int p = pos[i].first;
int h = pos[i].second;
int MIN = q + 1;
int index = -1;
for(int j = 0; j < m; j++)
{
if(speed[j] * p < 0)
{
if(abs(j - h) < MIN)
{
MIN = abs(j - h);
index = j;
}
}
}
if(index == -1)
return -1;
int t = p / speed[index];
if(speed[index] * t == p)
uset.insert(MP(abs(t), i));
else
uset.insert(MP(abs(t) + 1, i));
flag[i] = MIN;
energy[i] = MIN;
eng += MIN;
}
if(eng > q)
return -1;
int remain = q - eng;
while(remain > 0)
{
pair<int,int> slow = *(uset.begin());

uset.erase(uset.begin());
int limit = slow.first;
if(uset.size())
limit = uset.begin()->first;
int ii = slow.second;
int p = pos[ii].first;
int h = pos[ii].second;
remain += energy[ii];
int index=  -1;
int MIN = m + 1;
int T = -1;
for(int i = max(0, h - remain); i <= min(m - 1, h + remain); i++)
{
int tt = calc(p, speed[i]);

if(tt < limit)
{
if(abs(i - h) < MIN)
{
MIN = abs(i - h);
index = i;
T = tt;
}
}
}

if(index == -1 || remain < MIN)
{
uset.insert(slow);
break;
}
energy[ii] = MIN;
remain -= MIN;
uset.insert(MP(T,ii));
}
int ii = uset.begin()->second;
int tt = uset.begin()->first;
int p = pos[ii].first;
int h = pos[ii].second;

for(int i = max(0, h - remain); i <= min(m - 1, h + remain); i++)
{
int t = calc(p, speed[i]);
tt = min(tt,t);
}

return tt;

}
int main(){
int Tcase;
cin >> Tcase;

FOR(hh,0,Tcase)
{
cin >> n >> m >> q;
FOR(i,0,m)
cin >> speed[i];
FOR(i,0,n)
cin >> pos[i].first >> pos[i].second;
cout << "Case #" << hh + 1 << ": ";
uset.clear();
int res = solve();
if(res != -1)
cout << res << endl;
else
cout << "IMPOSSIBLE" << endl;
}

return 0;
}

Problem C. IP Address Summarization

这题当时卡了挺长时间，题意就是求最小的能表示当前网段的一个集合，因为比如1.0.0.0/9和1.128.0.0/9是可以合写成1.0.0.0/8的。对于斜杠后面的数我称它为掩码最低位。声明32个hashset，对于每个IP，先将其标准化后（和掩码&一下），然后转化为long long(高低位要分清楚，我是按照题意直接记录的，即1.0.0.0为00000001.24个0），因为32位数最高不超过2^32-1。根据掩码最低位的不同insert到不同的hashset里，这样先去重，然后从第32个hashset开始遍历所有的值，如果对第i个hashset的第j个值，设为val，如果val在第i位（从高向低）为1，那么看一下是否val去掉该位的值（val-(1<<(32-i))也在该hashset中，如果在的话就向前一个hashset中插入（val-(1<<(32-i))，当前hashset的不急着删除，反正下一步也会删除掉。

接下来就是去掉重合的subnet，仍旧从第32个hashset开始，对于每一项，如果一个一个去掉2进制中得1之后，所得到的值在之前的某个hashset中出现，则说明前面的subnet可以覆盖当前的，删掉即可。

复杂度为O(32 * 32 * n)

这题本身不难，我写的可能复杂了很多，主要是当时index从0或者从1开始理解起来很混乱，想清楚了以后实现还是很简单，位操作还是能解决很多问题的

#define FOR(a, b, n) for(int (a) = (b); (a) < (n); ++(a))
#define ITE(a, v) for(auto (a) = v.begin(); (a) != v.end(); ++(a))
#define LL long long
#define ALL(v) v.begin(),v.end()
#define ZERO(v) memset(v, 0, sizeof v)
#define NEG(v)  memset(v, -1, sizeof v)
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define MOD 1000000007
#define PI 3.141592653589793
inline long double min(long double a , long double b) {if(a < b)return a; return b;}
inline long double max(long double a , long double b) {if(a < b)return b; return a;}

int n;
unordered_set<LL> uset[33];

string conv(LL val)
{
vector<int> res(4);
for(int i = 3; i >= 0 ; i--)
{
res[i] = val % 256;
val /= 256;
}
string r;
FOR(i,0,res.size())
{
r += to_string(res[i]);
r.PB('.');
}
r.pop_back();
return r;
}
vector<int> split(string s)
{
int pos2 = s.find('.');
int pos1 = 0;
vector<string> res;
while(pos2 != -1)
{
res.PB(s.substr(pos1, pos2 - pos1));
pos1 = pos2 + 1;
pos2 = s.find('.', pos1 );
}
if(pos1 != s.size())
res.PB(s.substr(pos1));
vector<int> ans;
FOR(i,0,res.size())
ans.PB(stoi(res[i]));
return ans;
}
void clearPos(LL &val, LL base)
{
if((val & base) == 0)
return;
val -= base;
}

int main(){
int Tcase;
cin >> Tcase;

FOR(hh,0,Tcase)
{
FOR(i,0,33)
uset[i].clear();
cin >> n;
FOR(i,0,n)
{
string s;
cin >> s;
int pos = s.find('/');
int val = stoi(s.substr(pos + 1));
vector<int> temp = split(s.substr(0,pos));
LL tmp = 0;
LL base = 1;
for(int j = 3; j >= 0; j--)
{
tmp += base * temp[j];
base *= 256;
}
//cout << conv(tmp) << endl;
base = 1LL <<(32 -val);
base /= 2;
for(int j = val + 1; j <= 32; j++,base /= 2)
{
clearPos(tmp,base);
}
uset[val].insert(tmp);
}
LL base = 1;
for(int i = 32; i >= 1; i--, base *= 2)
{
ITE(j,uset[i])
{
LL val = *j;
if((val & base) != 0)
{
LL val2 = val - base;
if(uset[i].count(val2) == 1)
uset[i- 1].insert(val2);
}
else
{
LL val2 = val | base;
if(uset[i].count(val2) == 1)
uset[i- 1].insert(val);
}
}
}
base = 1;
for(int i = 32; i >= 1; i--, base *= 2)
{
vector<LL> E;
ITE(j,uset[i])
{
LL tmpBase = base;
LL val = *j;
clearPos(val, tmpBase);
tmpBase *= 2;
bool flag=  false;
for(int k = i - 1; k >= 0; k--, tmpBase *= 2)
{
if(uset[k].count(val) == 1)
{
flag = true;
break;
}
clearPos(val, tmpBase);
}
if(flag)
E.PB(*j);
}
FOR(j,0,E.size())
uset[i].erase(E[j]);
}
set<pair<LL,int> > ans;
for(int i = 32; i >= 1; i--, base *= 2)
{
ITE(j,uset[i])
{
ans.insert(MP(*j,i));
}
}
cout << "Case #" << hh + 1 << ":" << endl;
ITE(i,ans)
cout << conv(i->first) << "/" << i->second << endl;

// cout << solve() << endl;
}

return 0;
}

Problem D. Virtual Rabbit

没做出来，感觉没什么头绪，待我研究了大神的代码以后补上