虽然应该没多少人会用到日归档的功能，但是对我而言还是有用的，因为比如说过去贴代码那会儿好多天都是一天发几篇的，而且侧边栏还有个月历的挂件，因此还是把生成日归档的功能打开了。但是这个功能有个 bug，就是有的时候每个月之后生成第一天的日归档。
已经有人在 GitHub 上提交了 issue，不过看上去时间蛮久了也没改动，所以翻了下代码自己 commit 修掉了，也提 PR 了但是过不了测试 1，不是很懂 Node.js 所以也没继续去修。。
不过其实只加了对引号还是进文件自己改吧。
Hexo 根目录下的 node_modules/hexo-generator-archive/lib/generator.js 第 70 行改为
if (!posts[year][month].hasOwnProperty('day')) {保存后再运行 hexo g 应该就能正常生成日归档了。
我认为他测试用的判断逻辑有误。。↩
这是自用笔记所以所写的代码有可能不是很通用，遇错请自行修改。。
var count = 0;
function clickdelbtn() {
console.log(count + '-1');
document.getElementsByClassName('delBtn')[0].click()
setTimeout(clickdelchose, 3000);
}
function clickdelchose() {
console.log(count + '-2');
document.getElementsByClassName('delChose')[0].children[2].children[0].click()
count += 1;
setTimeout(clickdelbtn, 3000);
}import requests
import json
import re
import csv
import time
talk_headers = ['bkname', 'contAdd', 'content', 'count', 'counts', 'eventId', 'flag', 'from', 'fromIco', 'fromTxt',
'fromid', 'gender', 'height', 'height', 'icon', 'id', 'image', 'imageInfo', 'img', 'media', 'miniMedia',
'name', 'nick', 'node', 'node', 'passCert', 'phoneCert', 'pic', 'qinfo', 'realtime', 'rich', 'sign',
'signIcon', 'signSubType', 'source', 'status', 'syncQzone', 'tid', 'time', 'timestamp', 'tran', 'tv',
'tvs', 'type', 'type', 'type', 'videos', 'width']
t_cookie = ''
talksCount = 0
lastTimestamp = ''lastId =''
startTime = time.time()
def delTalk(talk):
print('- - Delete Id:', talk['id'])
print('- - - Content:', talk['content'])
print('- - - Time:', talk['time'])
url = 'http://api.t.qq.com/old/delete.php'
payload = {
'id': talk['id'],
'apiType': 14,
'apiHost': 'http://api.t.qq.com'
}
headers = {
'Referer': 'http://api.t.qq.com/proxy.html',
'Cookie': t_cookie
}
dsTime = time.time()
r = requests.post(url, data=payload, headers=headers)
data = json.loads(
r.text.replace('result', '"result"').replace('msg', '"msg"').replace('info', '"info"').replace('\'', '"'))
if data['result'] != 0:
raise RuntimeError('Delete Failed.')
print('- - Msg:', data['msg'], '', time.time() - dsTime,'seconds.')
def handleTalks(talks):
global talksCount, lastTimestamp, lastId
if len(talks) == 0:
raise RuntimeError('No talks.')
talksCount = talksCount + len(talks)
print('- Got', len(talks), 'Talks. Total:', talksCount)
lastId = talks[len(talks) - 1]['id']
lastTimestamp = talks[len(talks) - 1]['timestamp']
with open('talks.csv', 'a') as f:
f_csv = csv.DictWriter(f, talk_headers)
f_csv.writerows(talks)
for talk in talks:
delTalk(talk)
def getTalks(page):
global lastTimestamp, lastId
print('Page:', page)
url = 'http://api.t.qq.com/asyn/index.php'
if page > 1:
params = {
'id': lastId,
'time': lastTimestamp,
'page': page,
'isrecom': 0,
'apiType': 14,
'apiHost': 'http://api.t.qq.com'
}
else:
params = {
'page': page,
'isrecom': 0,
'apiType': 14,
'apiHost': 'http://api.t.qq.com'
}
headers = {
'Referer': 'http://api.t.qq.com/proxy.html',
'Cookie': t_cookie
}
rsTime = time.time()
r = requests.get(url, params=params, headers=headers)
t = re.sub(r"(msg:)\'(.*?)\'", r'\1"\2"', r.text)
t = re.sub(r"(\'user\':)\'(.*?)\'", r'\1"\2"', t)
data = json.loads(t.replace('result', '"result"').replace('msg', '"msg"').replace('\'info\'','"info"') \
.replace('\'user\'','"user"').replace('\'hasNext\'', '"hasNext"').replace('\'time\'','"time"'). \
replace('\'talk\'','"talk"').replace('\'noSign\'', '"noSign"') \
.replace('\'signuserinfo\'','"signuserinfo"'))
print('- Connected:', data['msg'], '', time.time() - rsTime,'seconds.')
if data['result'] != 0:
raise RuntimeError('No result.')
info = data['info']
print('- User:', info['user'])
handleTalks(info['talk'])
if info['hasNext']:
getTalks(page + 1)
if __name__ == '__main__':
print('Project Start.')
with open('talks.csv', 'a') as f:
f_csv = csv.DictWriter(f, talk_headers)
f_csv.writeheader()
try:
getTalks(1)
print('---------------------------')
print('Deleted All', talksCount, 'Talks.')
print('Runtime:', time.time() - startTime, 'seconds.')
except RuntimeError as e:
for i in e.args:
print(i)不管怎样很快就能删完了，反正这种脚本也就只会用到一次╮(╯▽╰)╭。
]]>但是大概是秉承一贯的优良作风，阿里云所提供的系统模板并不是官方最初始的，比如添加了很多很多诸如自己的源地址之类的，或许对于位于国内的服务器有效果，但是为什么国际版也有这些乱七八糟的玩意啊，而且理论算是内网连接吧但是不知道速度是怎么回事还不如官方源快。
所以我都是重装系统后第一时间把这些配置文件初始化到默认状态。
rm /etc/apt/apt.confvi /etc/apt/sources.list# Ubuntu 16.04
deb http://archive.ubuntu.com/ubuntu/ xenial main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ xenial-security main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ xenial-updates main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu/ xenial-backports main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu/ xenial main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu/ xenial-security main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu/ xenial-updates main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu/ xenial-backports main restricted universe multiverse
## 测试版源
deb http://archive.ubuntu.com/ubuntu/ xenial-proposed main restricted universe multiverse
deb-src http://archive.ubuntu.com/ubuntu/ xenial-proposed main restricted universe multiversevi /etc/resolvconf/resolv.conf.d/tailoptions timeout:1 attempts:2 rotate
nameserver 8.8.8.8
nameserver 8.8.4.4
nameserver 2001:4860:4860::8888rm ~/.pip/pip.conf最主要的当然是十几天的时间自己写了一个主题。作为前端新手半抄半查的拼出来了至少能看的页面，好多 CSS 感觉蛮混乱的。不过用自己的主题有一点好的就是哪里出 bug 了看的不顺眼了很方便就知道是哪里的问题，可以随手改。
当然为了让博客符合自己的习惯，还是做了不少的自定义。
名字可以算是乱起的啦 =_=
还没完工，比如评论以及顶上的导航栏点进去的页面可以算是都还没弄。只是开学了想扔一段时间再说。。
因为要写 Latex 数学公式所以用了 Mathjax 渲染，但是默认的 markdown 渲染引擎会与数学公式所用到的下划线星号等有冲突，所以我是选择了 markdown 的扩展语法 Pandoc 进行渲染。首先要在自己的系统上 安装 Pandoc，然后是更换 hexo 的渲染引擎。
brew install pandoc
npm install hexo-renderer-pandoc --save分别是生成 sitemap、RSS、给外站链接添加 nofollow 属性。
npm install hexo-generator-sitemap --save
npm install hexo-generator-feed --save
npm install hexo-autonofollow --save因为主题用到了日历 widget 所以开启了日归档，修改 node_modules/hexo-generator-archive/index.js 中的 daily 参数。
hexo.config.archive_generator = assign({
per_page: per_page,
yearly: true,
monthly: true,
daily: true
}, hexo.config.archive_generator);修改原生的首页生成方法 node_modules/hexo-generator-index/lib/generator.js 在 return pagination 前添加
posts.data = posts.data.sort(function (a, b) {
if (a.top && b.top) {
if (a.top == b.top) return b.date - a.date;
else return b.top - a.top;
}
else if (a.top && !b.top) {
return -1;
}
else if (!a.top && b.top) {
return 1;
}
else return b.date - a.date;
});官方的插件许久不更新了，反正都是调用的 pang.js，于是干脆自己写了个调用的最新版的 hexo-pangu-spacing，虽然好像时而会有莫名其妙的 bug 出现 1。。。
npm install hexo-pangu-spacing --save查了下这算是目前见到的唯一一款支持代码因网页宽度自适应换行后还能正确显示行号的 代码高亮插件，所以用到了自己的主题里，然后在配置文件_config.yml` 中关闭自带的代码高亮。
highlight:
enable: false不是很喜欢链接中加日期以及希望能自己选择 url，所以配置文件 _config.yml 中修改了文章链接的格式。
permalink: post/:url/修改生成文章的模板 scaffolds/post.md，在 Front-matter 部分添加
tags:
- null
categories:
- uncategorized
mathjax: false
top: 0
url: 因为不知道什么的缘故我的 VPS 生成不了网页总是会在 hexo g 的时候卡住 2，所以只能选择在本地生成好后复制到服务器上。
npm install hexo-deployer-rsync --save配置文件 _config.yml 中修改为
deploy:
type: rsync
host: #服务器地址
user: root
port: 22
root: #服务器上的目录又是三月。距上一篇博文的发表已经过去两年的时光。其实这之中也曾想着有些东西可以写写放上来的，但是终究没有成文，于是还在登录 WordPress 后台的时候看到一篇不知啥时候留下的草稿惊讶了一小下。
依然三月。三年前第一篇博文也是写于三月的日子里。那么我想大概也可算是某种意义上的回归吧。在大学之后感觉更是需要写些什么锻炼下自己的语言表达能力呢。
切换到 Hexo 静态博客。
用上了自己写的主题。
从 OI 进阶到了 ACM.
Write the code. Change the world.
]]>完成以下步骤之后每次开机登录只要能保证能正常联网就可以发现系统时间可以自动更正了。
首先我们新建一个文本文档，命名随意但后缀名设置为. vbs，比如我这里设置的就是 SyncTime.vbs，复制以下代码，保存到任意文件夹。
Set ws = CreateObject("Wscript.Shell")
ws.run "net start w32time" , vbhide
ws.run "w32tm /resync" , vbhide打开任务计划程序（运行 -“taskschd.msc”），按如图设置添加进去上面那个脚本的位置。
确定之后正常情况这个脚本就可以在每次登录账户时运行了，而之后我们也可以在上次运行时间里检测它是否正常运行了。
那么注销或者重启看看效果吧 (●‘◡’●)。
]]>那么其全称必然是引起了大家的关注，这样两个字母的全称到底是什么呢？Harold&Reese？HuaiRen(坏人)？或者按中文维基的“高层”？。。。
殊不知，其实编剧已经在第二季中已经给出了答案。
这也是我第二次复习的时候发现的。
第二季第五集，大约是 14:31 的时候，出现了记者对于 HR 头目的报到，镜头给了新闻稿一个特写，从图片上可以看出有这样一句话：“Following yesterday’s massive arrests in the growing NYPD scandal, numerous sources confirm that the FBI is close to arresting the man in charge of the network of corrupt police known as’Human Resources‘or’HR’.”
于是呢，可以得到官方对于这个问题还是给出了答案的，那就是所谓的“人力资源”-Human Resources…
当然你想认为是 Harold&Reese 或者 HuaiRen 的话… 嗯开心就好（≧∇≦）
]]>对于一些系统级应用（比如 iTunes Store）我们可以通过打开访问限制来使其隐藏，那么其他的应用呢？越狱之后就有了无限的可能性，除了使用一些专门的软件来隐藏之外，还可以通过手动修改其配置文件来使其隐藏。
这里以如图所示的最后一个应用 Activator 为例，仅需简单三个步骤即可把它隐藏起来：
使用 iFile 等程序以文本编辑模式打开该应用程序文件夹目录下的 Info.plist 文件。（系统级应用在 / Applications / 目录下，用户级应用在每个软件的 *.app / 目录下（注意这里 iOS7 和 iOS8 是不一样的位置））。
复制如下代码粘贴至第一个 < dict > 之后（或同级任意位置），如图。
<key>SBAppTags</key>
<array>
<string>Hidden</string>
</array>
当然解决这一问题的方法也很简单，就是让两个系统识别硬件时间的标准统一，以下推荐两种方法，选择其中之一就行了。
方法一：修改 Windows 注册表，让其将硬件时间识别为 UTC 时间。
打开运行窗口（Win 徽标 + R），输入 CMD（Vista 以上用户需要用管理员方式运行），输入以下命令并回车。
Reg add HKLM\SYSTEM\CurrentControlSet\Control\TimeZoneInformation /v RealTimeIsUniversal /t REG_DWORD /d 1提示操作成功完成，重启即可发现 windows 时间恢复正常。
方法二：安装补丁，让 Mac 把硬件时间当作本地时间。
下载补丁文件 LocalTimeToggle.pkg 在 mac 中双击运行安装即可。
以上两种方式均可以解决 mac 和 win 时间不同步的问题，但就实现方式而言还是推荐修改 windows 注册表的方法。
]]>网上有好多种去除快捷方式箭头的方法，这里介绍一种比较方便的方法吧，也是我一直以来使用的，亲测在 Windows 8 一直到 Windows 10 都是有效果的。
保存 Empty.ico 到 C:\windows 中
新建文本文档，复制以下内容保存。
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Icons]
"29"="C:\\Windows\\Empty.ico,0"
修改后缀名为. reg，双击导入注册表。
注销或者重启。
恢复的方式只需把. reg 文件内容替换为以下内容后导入注册表即可。
Windows Registry Editor Version 5.00
[-HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Icons]There is a skyscraping tree standing on the playground of Nanjing University of Science and Technology. On each branch of the tree is an integer (The tree can be treated as a connected graph with N vertices, while each branch can be treated as a vertex). Today the students under the tree are considering a problem: Can we find such a chain on the tree so that the multiplication of all integers on the chain (mod 106 + 3) equals to K?
Can you help them in solving this problem?
There are several test cases, please process till EOF.
Each test case starts with a line containing two integers N(1 <= N <= 105) and K(0 <=K < 106 + 3). The following line contains n numbers vi(1 <= vi < 106 + 3), where vi indicates the integer on vertex i. Then follows N - 1 lines. Each line contains two integers x and y, representing an undirected edge between vertex x and vertex y.
For each test case, print a single line containing two integers a and b (where a < b), representing the two endpoints of the chain. If multiply solutions exist, please print the lexicographically smallest one. In case no solution exists, print “No solution”(without quotes) instead.
For more information, please refer to the Sample Output below.
5 60
2 5 2 3 3
1 2
1 3
2 4
2 5
5 2
2 5 2 3 3
1 2
1 3
2 4
2 5
3 4
No solution
点分治 + 逆元 + Hash(其实可以不用)。各种 Debug 后自己都不认识了。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#pragma comment(linker,"/STACK:102400000,102400000")
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 100005;
const int maxm = 2 * maxn;
const int mod = 1000003;
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, nx;
} e[maxm];
int head[maxn], son[maxn], val[maxn];
int mp[mod + 5], use[mod + 5];
bool vis[maxn];
int cnt, num, ans1, ans2, a, b, c, siz;
long long inv[mod + 5];
inline void ins(int u, int v)
{
e[++cnt].to = v; e[cnt].nx = head[u];
head[u] = cnt;
}
int ms[maxn], pos;
void dfs(int u, int fa)
{
int i, v;
son[u] = 1;
ms[u] = 0;
for (i = head[u]; i; i = e[i].nx)
{
v = e[i].to;
if (v == fa || vis[v]) continue;
dfs(v, u);
son[u] += son[v];
ms[u] = max(ms[u], son[v]);
}
}
//================
void findroot(int u, int fa, int all)
{
int i, v;
ms[u] = max(ms[u], all - son[u]);
if (ms[u] < ms[pos]) pos = u;
for (i = head[u]; i; i = e[i].nx)
{
v = e[i].to;
if (v == fa || vis[v]) continue;
findroot(v, u, all);
}
}
int getroot(int u)
{
dfs(u, -1);
pos = u;
findroot(u, -1, son[u]);
return pos;
}
//=============
void calc(int u, int fa, int t)
{
t = (long long)t * val[u] % mod;
int i, v, c = (long long)k * inv[t] % mod;
if (mp[c])
{
a = u; b = mp[c];
if (a > b) swap(a, b);
if (a < ans1) ans1 = a, ans2 = b;
else if (a == ans1 && b < ans2) ans2 = b;
}
for (i = head[u]; i; i = e[i].nx)
{
v = e[i].to;
if (!vis[v] && v != fa) calc(v, u, t);
}
}
void update(int u, int fa, int t)
{
t = (long long)t * val[u] % mod;
int i, v;
if (!mp[t]) use[num++] = t, mp[t] = u;
else mp[t] = min(mp[t], u);
for (i = head[u]; i; i = e[i].nx)
{
v = e[i].to;
if (!vis[v] && v != fa) update(v, u, t);
}
}
//=============
void solve(int s)
{
int i, v;
mp[val[s]] = s;
vis[s] = true; num = 0;
for (i = head[s]; i; i = e[i].nx)
{
v = e[i].to;
if (!vis[v])
{
calc(v, s, 1);
update(v, s, val[s]);
}
}
for (i = 0; i < num; i++) mp[use[i]] = 0;
mp[val[s]] = 0;
for (i = head[s]; i; i = e[i].nx)
{
v = e[i].to;
if (!vis[v])
{
r = getroot(v);
solve(r);
}
}
}
//=============
int main()
{
inv[1] = 1;
for (i = 2; i < mod; i++) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
while (scanf("%d%d", &n, &k) != EOF)
{
memset(head, 0, sizeof(head));
memset(vis, false, sizeof(vis));
cnt = 0;
for (i = 1; i <= n; i++) scanf("%d", &val[i]);
for (i = 1; i < n; i++) scanf("%d%d", &x, &y), ins(x, y), ins(y, x);
ans1 = ans2 = inf;
r = getroot(1);
solve(r);
if (ans1 != inf) printf("%d %d\n", ans1, ans2);
else printf("No solution\n");
}
return 0;
}聪聪和可可是兄弟俩，他们俩经常为了一些琐事打起来，例如家中只剩下最后一根冰棍而两人都想吃、两个人都想玩儿电脑（可是他们家只有一台电脑）…… 遇到这种问题，一般情况下石头剪刀布就好了，可是他们已经玩儿腻了这种低智商的游戏。他们的爸爸快被他们的争吵烦死了，所以他发明了一个新游戏：由爸爸在纸上画 n 个 “点”，并用 n-1 条“边” 把这 n 个 “点” 恰好连通（其实这就是一棵树）。并且每条 “边” 上都有一个数。接下来由聪聪和可可分别随即选一个点（当然他们选点时是看不到这棵树的），如果两个点之间所有边上数的和加起来恰好是 3 的倍数，则判聪聪赢，否则可可赢。聪聪非常爱思考问题，在每次游戏后都会仔细研究这棵树，希望知道对于这张图自己的获胜概率是多少。现请你帮忙求出这个值以验证聪聪的答案是否正确。
输入的第 1 行包含 1 个正整数 n。后面 n-1 行，每行 3 个整数 x、y、w，表示 x 号点和 y 号点之间有一条边，上面的数是 w。
以即约分数形式输出这个概率（即 “a/b” 的形式，其中 a 和 b 必须互质。如果概率为 1，输出“1/1”）。
5
1 2 1
1 3 2
1 4 1
2 5 3
13/25
点分治，只需要统计边权除以三余数为 0,1,2 的情况即可。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 10005;
const int maxm = maxn * 2;
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, vl, nx;
} e[maxm];
int head[maxn], dis[maxn], a[maxn], son[maxn];;
bool vis[maxn];
int cnt, num, ans, len, siz, c;
void dfs(int u, int fa)
{
int i, t, v;
son[u] = 1;
for (t = 0, i = head[u]; i; i = e[i].nx)
{
v = e[i].to;
if (!vis[v] && v != fa)
{
dfs(v, u);
son[u] += son[v];
t = max(t, son[v]);
}
}
t = max(t, m - son[u]);
if (t < siz) c = u, siz = t;
}
int getcenter(int s)
{
c = 0; siz = inf;
dfs(s, -1);
return c;
}
inline void ins(int u, int v, int w)
{
e[++cnt] = (edge)
{
v, w, head[u]
}; head[u] = cnt;
e[++cnt] = (edge)
{
u, w, head[v]
}; head[v] = cnt;
}
void getarray(int u, int fa)
{
int i, v, w;
a[++len] = dis[u];
for (i = head[u]; i; i = e[i].nx)
{
v = e[i].to; w = e[i].vl;
if (!vis[v] && v != fa) dis[v] = dis[u] + w, getarray(v, u);
}
}
int calc(int u, int now)
{
int ans = 0;
dis[u] = now; len = 0;
getarray(u, -1);
sort(a + 1, a + len + 1);
l = 1; r = len;
while (l < r)
{
if (a[r] + a[l] <= k) ans += (r - l), l++;
else r--;
}
return ans;
}
void solve(int s)
{
int i, v, w;
ans += calc(s, 0);
vis[s] = true;
for (i = head[s]; i; i = e[i].nx)
{
v = e[i].to; w = e[i].vl;
if (!vis[v])
{
ans -= calc(v, w);
m = son[v];
r = getcenter(v);
solve(r);
}
}
}
int main()
{
while (scanf("%d%d", &n, &k) != EOF)
{
cnt = 0;
if (n == 0 && k == 0) break;
memset(head, 0, sizeof(head));
memset(vis, 0, sizeof(vis));
for (i = 1; i < n; i++) scanf("%d%d%d", &x, &y, &z), ins(x, y, z);
ans = 0;
m = n;
r = getcenter(1);
solve(r);
printf("%d\n", ans);
}
return 0;
}Give a tree with n vertices,each edge has a length(positive integer less than 1001).
Define dist(u,v)=The min distance between node u and v.
Give an integer k,for every pair (u,v) of vertices is called valid if and only if dist(u,v) not exceed k.
Write a program that will count how many pairs which are valid for a given tree.
The input contains several test cases. The first line of each test case contains two integers n, k. (n<=10000) The following n-1 lines each contains three integers u,v,l, which means there is an edge between node u and v of length l.
The last test case is followed by two zeros.
For each test case output the answer on a single line.
5 4
1 2 3
1 3 1
1 4 2
3 5 1
0 0
8
点分治。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 10005;
const int maxm = maxn * 2;
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, vl, nx;
} e[maxm];
int head[maxn], dis[maxn], a[maxn], son[maxn];;
bool vis[maxn];
int cnt, num, ans, len, siz, c;
void dfs(int u, int fa)
{
int i, t, v;
son[u] = 1;
for (t = 0, i = head[u]; i; i = e[i].nx)
{
v = e[i].to;
if (!vis[v] && v != fa)
{
dfs(v, u);
son[u] += son[v];
t = max(t, son[v]);
}
}
t = max(t, m - son[u]);
if (t < siz) c = u, siz = t;
}
int getcenter(int s)
{
c = 0; siz = inf;
dfs(s, -1);
return c;
}
inline void ins(int u, int v, int w)
{
e[++cnt] = (edge)
{
v, w, head[u]
}; head[u] = cnt;
e[++cnt] = (edge)
{
u, w, head[v]
}; head[v] = cnt;
}
void getarray(int u, int fa)
{
int i, v, w;
a[++len] = dis[u];
for (i = head[u]; i; i = e[i].nx)
{
v = e[i].to; w = e[i].vl;
if (!vis[v] && v != fa) dis[v] = dis[u] + w, getarray(v, u);
}
}
int calc(int u, int now)
{
int ans = 0;
dis[u] = now; len = 0;
getarray(u, -1);
sort(a + 1, a + len + 1);
l = 1; r = len;
while (l < r)
{
if (a[r] + a[l] <= k) ans += (r - l), l++;
else r--;
}
return ans;
}
void solve(int s)
{
int i, v, w;
ans += calc(s, 0);
vis[s] = true;
for (i = head[s]; i; i = e[i].nx)
{
v = e[i].to; w = e[i].vl;
if (!vis[v])
{
ans -= calc(v, w);
m = son[v];
r = getcenter(v);
solve(r);
}
}
}
int main()
{
while (scanf("%d%d", &n, &k) != EOF)
{
cnt = 0;
if (n == 0 && k == 0) break;
memset(head, 0, sizeof(head));
memset(vis, 0, sizeof(vis));
for (i = 1; i < n; i++) scanf("%d%d%d", &x, &y, &z), ins(x, y, z);
ans = 0;
m = n;
r = getcenter(1);
solve(r);
printf("%d\n", ans);
}
return 0;
}Consider a tree T with N (1 <= N <= 20,000) nodes numbered 1…N. Deleting any node from the tree yields a forest: a collection of one or more trees. Define the balance of a node to be the size of the largest tree in the forest T created by deleting that node from T.
For example, consider the tree:
Deleting node 4 yields two trees whose member nodes are {5} and {1,2,3,6,7}. The larger of these two trees has five nodes, thus the balance of node 4 is five. Deleting node 1 yields a forest of three trees of equal size: {2,6}, {3,7}, and {4,5}. Each of these trees has two nodes, so the balance of node 1 is two.
For each input tree, calculate the node that has the minimum balance. If multiple nodes have equal balance, output the one with the lowest number.
The first line of input contains a single integer t (1 <= t <= 20), the number of test cases. The first line of each test case contains an integer N (1 <= N <= 20,000), the number of congruence. The next N-1 lines each contains two space-separated node numbers that are the endpoints of an edge in the tree. No edge will be listed twice, and all edges will be listed.
For each test case, print a line containing two integers, the number of the node with minimum balance and the balance of that node.
1
7
2 6
1 2
1 4
4 5
3 7
3 1
1 2
找树的重心和去掉重心之后子树最多的节点数。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 20005;
const int maxm = maxn * 2;
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, nx;
} e[maxm];
int head[maxn], used[maxn], son[maxn];
int cnt, num, T, ans, sum;
inline void ins(int u, int v)
{
e[++cnt] = (edge)
{
v, head[u]
}; head[u] = cnt;
}
void dfs(int u, int fa, int tim)
{
int i, t, v;
son[u] = 1;
used[u] = tim;
for (t = 0, i = head[u]; i != 0; i = e[i].nx)
{
v = e[i].to;
if (used[v] != tim && v != fa)
{
dfs(v, u, tim);
son[u] += son[v];
t = max(t, son[v]);
}
}
t = max(t, n - son[u]);
if ((t < sum) || (t == sum && ans > u))
{
ans = u;
sum = t;
}
}
inline void getcenter(int s)
{
ans = 0; sum = inf;
dfs(s, -1, ++num);
printf("%d %d\n", ans, sum);
}
int main()
{
num = 0;
scanf("%d", &T);
while (T--)
{
cnt = 0;
memset(head, 0, sizeof(head));
memset(son, 0, sizeof(son));
scanf("%d", &n);
for (i = 1; i < n; i++)
{
scanf("%d%d", &x, &y);
ins(x, y); ins(y, x);
}
getcenter(1);
}
return 0;
}高一一班的座位表是个 n*m 的矩阵，经过一个学期的相处，每个同学和前后左右相邻的同学互相成为了好朋友。这学期要分文理科了，每个同学对于选择文科与理科有着自己的喜悦值，而一对好朋友如果能同时选文科或者理科，那么他们又将收获一些喜悦值。作为计算机竞赛教练的 scp 大老板，想知道如何分配可以使得全班的喜悦值总和最大。
第一行两个正整数 n，m。接下来是六个矩阵第一个矩阵为 n 行 m 列 此矩阵的第 i 行第 j 列的数字表示座位在第 i 行第 j 列的同学选择文科获得的喜悦值。第二个矩阵为 n 行 m 列 此矩阵的第 i 行第 j 列的数字表示座位在第 i 行第 j 列的同学选择理科获得的喜悦值。第三个矩阵为 n-1 行 m 列 此矩阵的第 i 行第 j 列的数字表示座位在第 i 行第 j 列的同学与第 i+1 行第 j 列的同学同时选择文科获得的额外喜悦值。第四个矩阵为 n-1 行 m 列 此矩阵的第 i 行第 j 列的数字表示座位在第 i 行第 j 列的同学与第 i+1 行第 j 列的同学同时选择理科获得的额外喜悦值。第五个矩阵为 n 行 m-1 列 此矩阵的第 i 行第 j 列的数字表示座位在第 i 行第 j 列的同学与第 i 行第 j+1 列的同学同时选择文科获得的额外喜悦值。第六个矩阵为 n 行 m-1 列 此矩阵的第 i 行第 j 列的数字表示座位在第 i 行第 j 列的同学与第 i 行第 j+1 列的同学同时选择理科获得的额外喜悦值。
输出一个整数，表示喜悦值总和的最大值
2 3
1534 2296 345
551 1429 4085
1488 2707 3095
1198 3778 1811
3571 4832 1658
2894 2742 1118
1690 2112
1279 4179
466 3002
3977 4256
32532
为求最大收益，则把所有可能的获益之和再减去为达到合理方案而减少的最少的收益，所以可得求最小割。分文理科考虑，源点与每个点建边容量为文科收益，每个点向汇点建边容量为理科收益，于是最后所有点会被分成两个集合，S 集合为选文科的，T 集合为选理科的。
对于相邻的同学，若两人选的相同科，则割掉另一科的边，若不同则两科边都需割掉，所以建图为源点向相邻同学建边容量为文科收益一半，相邻同学向汇点建边容量为理科收益一半，之间也建边，容量为文理各一半之和。为了精度先乘以二处理最后答案再除以二。
自己的程序时间不忍直视。。。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
#define id(x,y) ((x-1)*m+y)
const int inf = 0x7fffffff;
const int maxn = 105 * 105;
const int maxm = maxn * 30;
const int dx[5] = {0, 0, 0, 1, -1};
const int dy[5] = {0, 1, -1, 0, 0};//R,L,D,U
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, fl, nx;
} e[maxm];
int head[maxn], dis[maxn], used[maxn], cur[maxn];
int cnt, num, ans;
int a[105][105][5];
deque <int> q;
inline void ins(int u, int v, int f)
{
e[cnt] = (edge)
{
v, f, head[u]
}; head[u] = cnt++;
e[cnt] = (edge)
{
u, 0, head[v]
}; head[v] = cnt++;
}
inline bool bfs(int s, int t, int tim)
{
int i, u, v;
while (!q.empty()) q.pop_front();
dis[s] = 0; used[s] = tim;
q.push_back(s);
while (!q.empty())
{
u = q.front(); q.pop_front();
for (i = head[u]; i != -1; i = e[i].nx)
{
v = e[i].to;
if (used[v] != tim && e[i].fl > 0)
{
used[v] = tim;
dis[v] = dis[u] + 1;
q.push_back(v);
}
}
}
return (used[t] == tim);
}
int dfs(int u, int t, int flow)
{
int v, d, f = flow;
if (u == t) return flow;
for (int &i = cur[u]; i != -1 && f > 0; i = e[i].nx)
{
v = e[i].to;
if (dis[v] == dis[u] + 1 && e[i].fl > 0)
{
d = dfs(v, t, min(f, e[i].fl));
e[i].fl -= d; e[i ^ 1].fl += d;
f -= d;
}
}
return flow - f;
}
inline void dinic(int s, int t)
{
while (bfs(s, t, ++num))
{
memcpy(cur, head, sizeof(head));
ans -= dfs(s, t, inf);
}
printf("%d\n", ans >> 1);
}
int main()
{
cnt = num = ans = 0;
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
{
scanf("%d", &x);
x <<= 1;
ans += x;
ins(0, id(i, j), x);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
{
scanf("%d", &x);
x <<= 1;
ans += x;
ins(id(i, j), n * m + 1, x);
}
for (i = 1; i < n; i++)
for (j = 1; j <= m; j++)
{
scanf("%d", &x);
ans += x << 1;
ins(0, id(i, j), x);
ins(0, id(i + 1, j), x);
a[i][j][3] = a[i + 1][j][4] += x;
}
for (i = 1; i < n; i++)
for (j = 1; j <= m; j++)
{
scanf("%d", &x);
ans += x << 1;
ins(id(i, j), n * m + 1, x);
ins(id(i + 1, j), n * m + 1, x);
a[i][j][3] = a[i + 1][j][4] += x;
}
for (i = 1; i <= n; i++)
for (j = 1; j < m; j++)
{
scanf("%d", &x);
ans += x << 1;
ins(0, id(i, j), x);
ins(0, id(i, j + 1), x);
a[i][j][1] = a[i][j + 1][2] += x;
}
for (i = 1; i <= n; i++)
for (j = 1; j < m; j++)
{
scanf("%d", &x);
ans += x << 1;
ins(id(i, j), n * m + 1, x);
ins(id(i, j + 1), n * m + 1 , x);
a[i][j][1] = a[i][j + 1][2] += x;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
for (k = 1; k <= 4; k++)
{
x = i + dx[k]; y = j + dy[k];
if (x > 0 && x <= n && y > 0 && y <= m) ins(id(i, j), id(x, y), a[i][j][k]);
}
dinic(0, n * m + 1);
return 0;
}一个循环格就是一个矩阵，其中所有元素为箭头，指向相邻四个格子。每个元素有一个坐标（行，列），其中左上角元素坐标为（0,0）。给定一个起始位置（r，c），你可以沿着箭头防线在格子间行走。即如果（r,c）是一个左箭头，那么走到（r，c-1）; 如果是右箭头那么走到（r，c+1）；如果是上箭头那么走到（r-1，c）；如果是下箭头那么走到（r+1，c）；每一行和每一列都是循环的，即如果走出边界，你会出现在另一侧。
一个完美的循环格是这样定义的：对于任意一个起始位置，你都可以 i 沿着箭头最终回到起始位置。如果一个循环格不满足完美，你可以随意修改任意一个元素的箭头直到完美。给定一个循环格，你需要计算最少需要修改多少个元素使其完美。
第一行两个整数 R，C。表示行和列，接下来 R 行，每行 C 个字符 LRUD，表示左右上下。
一个整数，表示最少需要修改多少个元素使得给定的循环格完美
3 4
RRRD
URLL
LRRR
2
构成一个循环即每个格子出度入度都相等为一，所以每个格子拆成入点和出点，源向入点建边容量一费用零，出点向汇点建边容量一费用零，然后相邻格子建边容量一费用为是否需要改符号。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <cmath>
#include <queue>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 20 * 20;
const int maxm = maxn * 10;
const int dx[5] = {0, 0, 0, 1, -1};
const int dy[5] = {0, 1, -1, 0, 0};
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, fl, co, nx;
} e[maxm];
int head[maxn], dis[maxn], used[maxn], pre[maxn];
int cnt, num, c;
char ch[20];
deque <int> q;
inline void ins(int u, int v, int f, int c)
{
e[cnt] = (edge)
{
v, f, c, head[u]
}; head[u] = cnt++;
e[cnt] = (edge)
{
u, 0, -c, head[v]
}; head[v] = cnt++;
}
inline bool spfa(int s, int t, int tim)
{
int i, u, v, w;
while (!q.empty()) q.pop_front();
for (i = s; i <= t; i++) dis[i] = inf;
dis[s] = 0; used[s] = tim; pre[s] = -1;
q.push_back(s);
while (!q.empty())
{
u = q.front(); q.pop_front(); used[u] = 0;
for (i = head[u]; i != -1; i = e[i].nx)
{
v = e[i].to; w = e[i].co;
if (dis[v] > dis[u] + w && e[i].fl > 0)
{
dis[v] = dis[u] + w;
pre[v] = i;
if (used[v] != tim)
{
used[v] = tim;
if (!q.empty() && dis[v] < dis[q.front()]) q.push_front(v);
else q.push_back(v);
}
}
}
}
return (dis[t] != inf);
}
inline void mcmf(int s, int t)
{
int i, f, ans = 0;
while (spfa(s, t, ++num))
{
for (f = inf, i = pre[t]; i != -1; i = pre[e[i ^ 1].to]) f = min(f, e[i].fl);
ans += f * dis[t];
for (i = pre[t]; i != -1; i = pre[e[i ^ 1].to]) e[i].fl -= f, e[i ^ 1].fl += f;
}
printf("%d\n", ans);
}
int main()
{
cnt = num = 0;
memset(head, -1, sizeof(head));
scanf("%d%d", &r, &c);
t = r * c;
for (i = 1; i <= r; i++)
{
scanf("%s", ch + 1);
for (j = 1; j <= c; j++)
{
ins(0, (i - 1)*c + j, 1, 0);
ins(t + (i - 1)*c + j, 2 * t + 1, 1, 0);
for (k = 1; k <= 4; k++)
{
x = i + dx[k]; if (x > r) x = 1; if (x < 1) x = r;
y = j + dy[k]; if (y > c) y = 1; if (y < 1) y = c;
if (k == 1) ins((i - 1)*c + j, t + (x - 1)*c + y, 1, (ch[j] == 'R') ? 0 : 1);
if (k == 2) ins((i - 1)*c + j, t + (x - 1)*c + y, 1, (ch[j] == 'L') ? 0 : 1);
if (k == 3) ins((i - 1)*c + j, t + (x - 1)*c + y, 1, (ch[j] == 'D') ? 0 : 1);
if (k == 4) ins((i - 1)*c + j, t + (x - 1)*c + y, 1, (ch[j] == 'U') ? 0 : 1);
}
}
}
mcmf(0, 2 * t + 1);
return 0;
}幼儿园里有 n 个小朋友打算通过投票来决定睡不睡午觉。对他们来说，这个问题并不是很重要，于是他们决定发扬谦让精神。虽然每个人都有自己的主见，但是为了照顾一下自己朋友的想法，他们也可以投和自己本来意愿相反的票。我们定义一次投票的冲突数为好朋友之间发生冲突的总数加上和所有和自己本来意愿发生冲突的人数。 我们的问题就是，每位小朋友应该怎样投票，才能使冲突数最小？
第一行只有两个整数 n，m，保证有 2≤n≤300，1≤m≤n(n-1)/2。其中 n 代表总人数，m 代表好朋友的对数。文件第二行有 n 个整数，第 i 个整数代表第 i 个小朋友的意愿，当它为 1 时表示同意睡觉，当它为 0 时表示反对睡觉。接下来文件还有 m 行，每行有两个整数 i，j。表示 i，j 是一对好朋友，我们保证任何两对 i，j 不会重复。
只需要输出一个整数，即可能的最小冲突数。
9 6
1 1 1 1 1 0 1 0 0
7 9
4 3
1 8
2 7
6 3
3 2
3
源点与同意的人建边容量无限，反对的人与汇点建边容量无限，互相是朋友的人建边容量一，求最小割。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 305;
const int maxm = 3 * maxn * maxn;
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, fl, nx;
} e[maxm];
int head[maxn], dis[maxn], used[maxn], cur[maxn];
int cnt, num;
deque <int> q;
inline void ins(int u, int v, int f)
{
e[cnt] = (edge)
{
v, f, head[u]
}; head[u] = cnt++;
e[cnt] = (edge)
{
u, 0, head[v]
}; head[v] = cnt++;
}
inline bool bfs(int s, int t, int tim)
{
int i, u, v;
while (!q.empty()) q.pop_front();
dis[s] = 0; used[s] = tim;
q.push_back(s);
while (!q.empty())
{
u = q.front(); q.pop_front();
for (i = head[u]; i != -1; i = e[i].nx)
{
v = e[i].to;
if (used[v] != tim && e[i].fl > 0)
{
used[v] = tim;
dis[v] = dis[u] + 1;
q.push_back(v);
}
}
}
return (used[t] == tim);
}
int dfs(int u, int t, int flow)
{
int v, d, f = flow;
if (u == t) return flow;
for (int &i = cur[u]; i != -1 && f > 0; i = e[i].nx)
{
v = e[i].to;
if (dis[v] == dis[u] + 1 && e[i].fl > 0)
{
d = dfs(v, t, min(f, e[i].fl));
e[i].fl -= d; e[i ^ 1].fl += d;
f -= d;
}
}
return flow - f;
}
inline void dinic(int s, int t)
{
int ans = 0;
while (bfs(s, t, ++num))
{
memcpy(cur, head, sizeof(head));
ans += dfs(s, t, inf);
}
printf("%d\n", ans);
}
int main()
{
cnt = num = 0;
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
{
scanf("%d", &x);
if (x == 1) ins(0, i, 1);
else ins(i, n + 1, 1);
}
for (i = 1; i <= m; i++)
{
scanf("%d%d", &x, &y);
ins(x, y, 1);
ins(y, x, 1);
}
dinic(0, n + 1);
return 0;
}“狼爱上羊啊爱的疯狂，谁让他们真爱了一场；狼爱上羊啊并不荒唐，他们说有爱就有方向．．．．．．” Orez 听到这首歌，心想：狼和羊如此和谐，为什么不尝试羊狼合养呢？说干就干！ Orez 的羊狼圈可以看作一个 n*m 个矩阵格子，这个矩阵的边缘已经装上了篱笆。可是 Drake 很快发现狼再怎么也是狼，它们总是对羊垂涎三尺，那首歌只不过是一个动人的传说而已。所以 Orez 决定在羊狼圈中再加入一些篱笆，还是要将羊狼分开来养。 通过仔细观察，Orez 发现狼和羊都有属于自己领地，若狼和羊们不能呆在自己的领地，那它们就会变得非常暴躁，不利于他们的成长。 Orez 想要添加篱笆的尽可能的短。当然这个篱笆首先得保证不能改变狼羊的所属领地，再就是篱笆必须修筑完整，也就是说必须修建在单位格子的边界上并且不能只修建一部分。
文件的第一行包含两个整数 n 和 m。接下来 n 行每行 m 个整数，1 表示该格子属于狼的领地，2 表示属于羊的领地，0 表示该格子不是任何一只动物的领地。
文件中仅包含一个整数 ans，代表篱笆的最短长度。
15 17
1 0 1 2 2 1 0 0 1 2 0 2 2 2 0 2 0
2 1 2 2 0 2 1 0 2 2 1 2 2 2 0 2 1
1 1 0 1 1 2 0 2 2 0 0 0 2 0 2 2 2
2 1 2 0 1 1 0 0 1 2 0 1 1 0 2 1 2
2 1 0 0 1 0 0 2 2 1 1 1 2 1 2 0 0
0 1 2 1 2 0 1 0 0 2 0 1 0 0 1 2 2
1 0 1 1 0 1 1 0 1 0 1 2 2 0 2 0 0
2 1 1 0 1 0 1 2 2 2 0 1 2 0 1 2 0
2 1 1 2 1 1 2 2 0 1 2 2 2 0 2 1 2
0 1 2 1 1 1 1 2 2 0 0 0 2 1 1 0 2
0 1 0 2 1 1 1 2 2 1 0 1 1 1 1 0 2
1 1 2 1 1 0 0 1 0 0 2 1 1 2 1 2 2
0 1 0 0 0 2 2 0 0 0 2 2 0 1 0 1 1
0 1 0 0 1 1 0 1 2 0 2 0 1 1 1 0 1
1 1 0 2 2 1 0 0 0 0 1 2 0 1 2 2 0
169
源点与狼建边容量无限，羊与汇点建边容量无限，中间相邻的狼向空点和羊、空点向空点和羊建边容量一，求最小割。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <deque>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 10005;
const int maxm = 5 * maxn;
const int dx[5] = {0, 0, 0, 1, -1};
const int dy[5] = {0, 1, -1, 0, 0};
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, fl, nx;
} e[maxm];
int head[maxn], dis[maxn], used[maxn], cur[maxn];
int a[105][105];
int cnt, num;
deque <int> q;
inline void ins(int u, int v, int f)
{
e[cnt] = (edge)
{
v, f, head[u]
}; head[u] = cnt++;
e[cnt] = (edge)
{
u, 0, head[v]
}; head[v] = cnt++;
}
inline bool bfs(int s, int t, int tim)
{
int i, u, v;
while (!q.empty()) q.pop_front();
dis[s] = 0; used[s] = tim;
q.push_back(s);
while (!q.empty())
{
u = q.front(); q.pop_front();
for (i = head[u]; i != -1; i = e[i].nx)
{
v = e[i].to;
if (used[v] != tim && e[i].fl > 0)
{
used[v] = tim;
dis[v] = dis[u] + 1;
q.push_back(v);
}
}
}
return (used[t] == tim);
}
int dfs(int u, int t, int flow)
{
int v, d, f = flow;
if (u == t) return flow;
for (int &i = cur[u]; i != -1; i = e[i].nx)
{
v = e[i].to;
if (dis[v] == dis[u] + 1 && e[i].fl > 0)
{
d = dfs(v, t, min(f, e[i].fl));
e[i].fl -= d; e[i ^ 1].fl += d;
f -= d;
if (f == 0) break;
}
}
return flow - f;
}
inline void dinic(int s, int t)
{
int ans = 0;
while (bfs(s, t, ++num))
{
memcpy(cur, head, sizeof(head));
ans += dfs(s, t, inf);
}
printf("%d\n", ans);
}
int main()
{
cnt = num = 0;
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (i = 1; i <= n; i++)
{
for (j = 1; j <= m; j++)
{
if (a[i][j] == 1) ins(0, m * (i - 1) + j, inf);
if (a[i][j] == 2) ins(m * (i - 1) + j, n * m + 1, inf);
if (a[i][j] != 2)
{
for (k = 1; k <= 4; k++)
{
x = i + dx[k]; y = j + dy[k];
if (x <= 0 || y <= 0 || x > n || y > m) continue;
if ((a[i][j] != 2 && a[x][y] != 1)) ins(m * (i - 1) + j, m * (x - 1) + y, 1);
}
}
}
}
dinic(0, m * n + 1);
return 0;
}某软件公司正在规划一项 n 天的软件开发计划，根据开发计划第 i 天需要 ni 个软件开发人员，为了提高软件开发人员的效率，公司给软件人员提供了很多的服务，其中一项服务就是要为每个开发人员每天提供一块消毒毛巾，这种消毒毛巾使用一天后必须再做消毒处理后才能使用。消毒方式有两种，A 种方式的消毒需要 a 天时间，B 种方式的消毒需要 b 天（b>a），A 种消毒方式的费用为每块毛巾 fA, B 种消毒方式的费用为每块毛巾 fB，而买一块新毛巾的费用为 f（新毛巾是已消毒的，当天可以使用）；而且 f>fA>fB。公司经理正在规划在这 n 天中，每天买多少块新毛巾、每天送多少块毛巾进行 A 种消毒和每天送多少块毛巾进行 B 种消毒。当然，公司经理希望费用最低。你的任务就是：为该软件公司计划每天买多少块毛巾、每天多少块毛巾进行 A 种消毒和多少毛巾进行 B 种消毒，使公司在这项 n 天的软件开发中，提供毛巾服务的总费用最低。
第 1 行为 n,a,b,f,fA,fB. 第 2 行为 n1，n2，……，nn. （注：1≤f,fA,fB≤60，1≤n≤1000）
最少费用
10 2 5 10 7 5
71 17 93 10 82 38 92 4 66 14
3947
把每天分为二分图两个集合中的顶点 Xi,Yi，建立附加源 S 汇 T。二分图 X 集合中顶点 Xi 表示第 i 天用完的餐巾, Y 集合中每个点 Yi 则是第 i 天需要的餐巾.
1、从 S 向每个 Xi 连一条容量为 ri，费用为 0 的有向边。
2、从每个 Yi 向 T 连一条容量为 ri，费用为 0 的有向边。
3、从 S 向每个 Yi 连一条容量为无穷大，费用为 p 的有向边。
4、从每个 Xi 向 Xi+1(i+1<=N) 连一条容量为无穷大，费用为 0 的有向边。
5、从每个 Xi 向 Yi+m(i+m<=N) 连一条容量为无穷大，费用为 f 的有向边。
6、从每个 Xi 向 Yi+n(i+n<=N) 连一条容量为无穷大，费用为 s 的有向边。
求网络最小费用最大流，费用流值就是要求的最小总花费。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 2005;
const int maxm = 6 * maxn;
int i, j, t, n, m, l, r, k, z, y, x;
int cnt, num, a, b, f, fa, fb;
struct edge
{
int to, fl, co, nx;
} e[maxm];
int head[maxn], dis[maxn], used[maxn], pre[maxn];
deque <int> q;
inline void ins(int u, int v, int f, int c)
{
e[cnt] = (edge)
{
v, f, c, head[u]
};
head[u] = cnt++;
e[cnt] = (edge)
{
u, 0, -c, head[v]
};
head[v] = cnt++;
}
inline bool spfa(int s, int t, int tim)
{
int i, u, v, w;
while (!q.empty()) q.pop_front();
for (i = s; i <= t; i++) dis[i] = inf;
dis[s] = 0; used[s] = tim; pre[s] = -1;
q.push_back(s);
while (!q.empty())
{
u = q.front(); q.pop_front(); used[u] = 0;
for (i = head[u]; i != -1; i = e[i].nx)
{
v = e[i].to; w = e[i].co;
if (dis[v] > dis[u] + w && e[i].fl > 0)
{
dis[v] = dis[u] + w;
pre[v] = i;
if (used[v] != tim)
{
used[v] = tim;
if (!q.empty() && dis[v] < dis[q.front()]) q.push_front(v);
else q.push_back(v);
}
}
}
}
return (dis[t] != inf);
}
inline void mcmf(int s, int t)
{
int i, f, ans = 0;
while (spfa(s, t, ++num))
{
// cout << " " << ans << endl;
for (f = inf, i = pre[t]; i != -1; i = pre[e[i ^ 1].to]) f = min(f, e[i].fl);
for (i = pre[t]; i != -1; i = pre[e[i ^ 1].to]) e[i].fl -= f, e[i ^ 1].fl += f;
ans += f * dis[t];
}
printf("%d\n", ans);
}
int main()
{
cnt = num = 0;
memset(head, -1, sizeof(head));
scanf("%d%d%d%d%d%d", &n, &a, &b, &f, &fa, &fb);
for (i = 1; i <= n; i++)
{
scanf("%d", &x);
ins(0, i, x, 0);
ins(n + i, 2 * n + 1, x, 0);
ins(0, n + i, inf, f);
}
for (i = 1; i < n; i++) ins(i, i + 1, inf, 0);
for (i = 1; i + a + 1 <= n; i++) ins(i, n + i + a + 1, inf, fa);
for (i = 1; i + b + 1 <= n; i++) ins(i, n + i + b + 1, inf, fb);
mcmf(0, 2 * n + 1);
return 0;
}发生了火警，所有人员需要紧急疏散！假设每个房间是一个 N M 的矩形区域。每个格子如果是’.‘，那么表示这是一块空地；如果是’X’，那么表示这是一面墙，如果是’D’，那么表示这是一扇门，人们可以从这儿撤出房间。已知门一定在房间的边界上，并且边界上不会有空地。最初，每块空地上都有一个人，在疏散的时候，每一秒钟每个人都可以向上下左右四个方向移动一格，当然他也可以站着不动。疏散开始后，每块空地上就没有人数限制了（也就是说每块空地可以同时站无数个人）。但是，由于门很窄，每一秒钟只能有一个人移动到门的位置，一旦移动到门的位置，就表示他已经安全撤离了。现在的问题是：如果希望所有的人安全撤离，最短需要多少时间？或者告知根本不可能。
输入文件第一行是由空格隔开的一对正整数 N 与 M，3<=N <=20，3<=M<=20，以下 N 行 M 列描述一个 N M 的矩阵。其中的元素可为字符’.‘、’X’和’D’，且字符间无空格。
只有一个整数 K，表示让所有人安全撤离的最短时间，如果不可能撤离，那么输出’impossible’（不包括引号）。
2 1
NY
NY
1
男女分别拆成两点 i,i’,j,j’，i->i’、j’->j 连边容量 k，男 i 女 j 喜欢连接 i->j、不喜欢连接 i’->j’容量均为一。二分答案，源点连接 i 容量二分值，j 连接汇点容量二分值，网络流验证最大流是否是二分值 * n。
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
const int inf = 0x7fffffff / 27.11;
const int maxn = 4 * 55;
const int maxm = maxn * maxn;
int i, j, t, n, m, l, r, k, z, y, x;
struct edge
{
int to, fl, cp, nx;
} e[maxm];
int head[maxn], dis[maxn], used[maxn], cur[maxn];
char ch[maxn];
int num, cnt, sum, mid;
deque <int> q;
inline void ins(int u, int v, int f, int c)
{
e[cnt] = (edge)
{
v, f, c, head[u]
}; head[u] = cnt++;
e[cnt] = (edge)
{
u, 0, 0, head[v]
}; head[v] = cnt++;
}
inline bool bfs(int s, int t, int tim)
{
int i, u, v;
while (!q.empty()) q.pop_front();
dis[s] = 0; used[s] = tim;
q.push_back(s);
while (!q.empty())
{
u = q.front(); q.pop_front();
for (i = head[u]; i != -1; i = e[i].nx)
{
v = e[i].to;
if (used[v] != tim && e[i].fl > 0)
{
used[v] = tim;
dis[v] = dis[u] + 1;
q.push_back(v);
}
}
}
return (used[t] == tim);
}
int dfs(int u, int t, int flow)
{
int i, v, d, k;
if (u == t) return flow;
for (d = flow, i = cur[u]; i != -1; i = e[i].nx)
{
v = e[i].to;
if (dis[v] == dis[u] + 1 && e[i].fl > 0)
{
k = dfs(v, t, min(d, e[i].fl));
e[i].fl -= k; e[i ^ 1].fl += k;
d -= k;
if (d == 0) break;
}
}
return flow - d;
}
inline bool dinic(int s, int t, int lim)
{
int i, ans = 0;
for (i = 0; i < cnt; i++) e[i].fl = (e[i].cp == -1) ? lim : e[i].cp;
while (bfs(s, t, ++num))
{
memcpy(cur, head, sizeof(head));
ans += dfs(s, t, inf);
}
return (ans == lim * n);
}
int main()
{
cnt = num = 0;
memset(head, -1, sizeof(head));
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) ins(0, i, 0, -1);
for (i = 1; i <= n; i++) ins(3 * n + i, 4 * n + 1, 0, -1);
for (i = 1; i <= n; i++) ins(i, n + i, k, k), ins(n * 2 + i, n * 3 + i, k, k);
for (i = 1; i <= n; i++)
{
scanf("%s", ch + 1);
for (j = 1; j <= n; j++)
{
if (ch[j] == 'Y') ins(i, 3 * n + j, 1, 1);
else ins(n + i, 2 * n + j, 1, 1);
}
}
l = 0; r = n;
while (l <= r)
{
mid = (l + r) >> 1;
if (dinic(0, 4 * n + 1, mid)) l = mid + 1 ;
else r = mid - 1;
}
printf("%d\n", l - 1);
return 0;
}