跳到内容
导航菜单
切换导航
登录
产品
行动
自动化任何工作流
包装
托管和管理包
安全
查找并修复漏洞
代码空间
即时开发环境
GitHub Copilot公司
使用AI编写更好的代码
代码审查
管理代码更改
问题
计划和跟踪工作
讨论
在代码外协作
探索
所有功能
文档
GitHub技能
博客
解决
按大小
企业
团队
创业公司
按行业划分
保健
金融服务
制造业
按用例
CI/CD和自动化
开发运营
开发安全操作
资源
话题
人工智能
开发运营
安全
软件开发
查看全部
探索
学习途径
白皮书、电子书、网络研讨会
客户案例
合作伙伴
开放源代码
GitHub赞助商
资助开源开发人员
ReadME项目
GitHub社区文章
存储库
话题
趋向
收藏
企业
企业平台
AI驱动的开发人员平台
可用附加组件
高级安全
企业级安全功能
GitHub Copilot公司
企业级AI功能
特优支持
企业级全天候支持
定价
搜索或跳转到。。。
搜索代码、存储库、用户、问题、推送请求。。。
搜索
清除
搜索语法提示
提供反馈
我们阅读了每一条反馈,并非常认真地对待您的意见。
包括我的电子邮件地址以便联系我
保存的搜索
使用保存的搜索更快地筛选结果
姓名
查询
要查看所有可用的限定符,请参阅我们的
文档
.
登录
注册
重置焦点
您使用另一个选项卡或窗口登录。
重新加载
刷新会话。
您在另一个选项卡或窗口中注销。
重新加载
刷新会话。
您在另一个选项卡或窗口上切换了帐户。
重新加载
刷新会话。
解除警报
{{消息}}
SnapDragon64
/
ACM最终解决方案
公共
通知
您必须登录才能更改通知设置
福克
94
星星
359
代码
问题
三
拉取请求
0
行动
项目
0
维基
安全
洞察力
其他导航选项
代码
问题
拉取请求
行动
项目
维基
安全
洞察力
文件夹
主人
面包屑
ACM最终解决方案
/
2018年决赛
/
非交叉骑士DK-compute.cc
责备
责备
最近一次提交
历史
历史
533行(484个位置)·20.8 KB
主人
面包屑
ACM最终解决方案
/
2018年决赛
/
非交叉骑士DK-compute.cc
顶部
文件元数据和控件
代码
责备
533行(484个位置)·20.8 KB
原始
1
2
三
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
//
这是我在研究原始数学问题时编写的代码,所以
//
做的比问题要求的多一点。
特别是,它输出
//
svg图表,它证明了循环是有效的(参赛者可以
//
假设),它还可以处理开放式旅行。
#
包括
<
算法
>
#
包括
<
卡塞特
>
#
包括
<
cstio公司
>
#
包括
<
c字符串
>
#
包括
<
湾流
>
#
包括
<
功能性的
>
#
包括
<
iostream公司
>
#
包括
<
队列
>
#
包括
<
设置
>
#
包括
<
s流
>
#
包括
<
一串
>
#
包括
<
矢量
>
使用
命名空间
标准
;
//
定义搜索的全局变量。
布尔
开放路径=
假
;
整数
NCol公司=
8
,N低=
8
;
结构
州
{
//
(v,nends,compGone)表示一行的部分状态。
//
位置0、3、6。。。
将0存储为空正方形,-1存储为不可用正方形(因为两条边连接在一起
//
从上方开始),或[component#]表示从上方开始的开放边缘。
//
位置2、5。。。
将[component#]存储为一个开放边,向右,位于一个方块和下一个方块的中间。
//
位置1、4。。。
将[component#]存储为一个开放边,向左,位于一个方块和下一个方块的中间。
//
请注意,对于闭合路径,组件#将始终显示两次。
对于开放路径,最多两条
//
组件只能显示1次。
向量<
烧焦
>v;
//
对于开放路径,存储到目前为止我们创建的路径端点数量,从0到2。
烧焦
嫩枝;
//
组件在此行或之前是否被无法恢复地封闭(或其边缘被放弃)。
//
对于正确的路径(打开或关闭),这只会发生一次。
布尔
compGone;
//
我们是否已经产生了这个州的所有继任者。
布尔
成功生成;
//
为了方便起见,请在此状态下存储打开的组件的数量。
烧焦
ncomp;
//
每个不同的州都有一个唯一的ID。
//
状态0是“结束”状态,未访问任何方块。
所有州都有这个继承人。
//
状态1是“开始”状态,未访问任何方块(但尚未关闭任何组件)。
整数
身份证件;
//
后续状态ID,以及过渡中添加了多少新骑士边。
生成缓慢。
向量<对<
整数
,
整数
>>成功;
静止的
向量<状态*>状态;
//
拥有st;
返回具有ID的规范化副本。
静止的
常数
州*
商店状态
(州*st){
结构
状态配置
{
布尔
操作人员
()(
常数
状态*st1,
常数
州*st2)
常数
{
如果
(st1->
奈兹
!=
st2->
奈兹
)
返回
st1->
奈兹
<st2->
奈兹
;
如果
(st1->
compGone公司
!=
st2->
compGone公司
)
返回
st1->
compGone公司
<st2->
compGone公司
;
返回
st1->
v(v)
<st2->
v(v)
;
}
};
静止的
套<
常数
状态*,StateCmp>StateSet;
成对<
倾斜型
(状态集)::const_iterator,
布尔
>res=状态集。
插入
(st);
常数
状态*newst=*res。
第一
;
如果
(参考。
第二
) {
标准->
身份证件
=州。
大小
();
州。
推回(_B)
(st);
如果
(标准->
身份证件
%
1000
==
0
) {
cout公司<<
"
生成
"
<<标准->
身份证件
<<
"
状态。
"
<<endl;
}
}
其他的
{
删除
标准;
}
返回
新闻;
}
//
沿着行v(在x1处)运行,选择连接到行v2(在>=x2处)的边。
//
递归地做出所有可能的选择,以生成所有可能的继承状态。
//
请注意,边总是以递增顺序添加到x1和x2中,因为它们不能交叉。
//
所以x2总是到目前为止添加的任何边的最右边的坐标。
//
为了提高效率,v2进行了适当修改。
静止的
空隙
genSucc公司
(矢量<
烧焦
>&v、,
整数
x1,矢量<
烧焦
>&v2中,
整数
x2,
整数
奈兹,
整数
compgone公司,
整数
国家科学院,
成对<
整数
,
整数
>*行,函数<
空隙
(
常数
州*,
整数
)>基金会){
如果
(x1==v。
大小
()) {
状态*nst=
新的
州
();
nst->
奈兹
=嫩度;
nst->
compGone公司
=已完成;
//
规范化组件,使其按最左边的边排序。
nst->
ncomp公司
=
0
;
nst->
v(v)
=v2;
对于
(
整数
我=
0
;
i<nst->
v(v)
.
大小
();
i++){
如果
(nst->
v(v)
[i] >标准测试->
ncomp公司
) {
nst->
ncomp公司
++;
整数
n1=nst->
v(v)
[i] ,n2=nst->
ncomp公司
;
如果
(n1!=n2)
对于
(
整数
j=i;
j<标准->
v(v)
.
大小
();
j++){
如果
(恩斯特->
v(v)
[j] ==n1)nst->
v(v)
[j] =n2;
其他的
如果
(nst->
v(v)
[j] ==n2)nst->
v(v)
[j] =n1;
}
}
}
//
如果一个组件没有连接到其他任何东西就消失了,我们会
//
最好只做一次,不能有任何遗漏。
如果
(compgone>
0
) {
断言
(已完成==
1
);
如果
(nst->
ncomp公司
>
0
||奈兹<
2
)
返回
;
}
创建_函数
(
商店状态
(nst)、nsq);
返回
;
}
如果
(v[x1]==
0
&&x1%
三
==
0
) {
//
我们在一个空旷的广场上。
//
选项1:什么都不做。
genSucc公司
(v,x1)+
1
,v2,x2,nends,compgone,nsq,lines,find_func);
//
选项2:打开新端点。
如果
(开放路径和链接<
2
) {
对于
(
整数
nx=x1-
6
;
nx≤x1+
6
;
nx(纳克斯)+=
4
) {
tryEdge(尝试边缘)
(v、x1、v2、x2、nx、-
1
,奈兹+
1
,康普戈内,nsq+
1
,lines,found_func);
}
}
//
选项3:一起开始两条新边。
对于
(
整数
nx=x1-
6
;
nx<x1+
6
;
nx(纳克斯)+=
4
)
对于
(
整数
nx2=nx+
4
;
nx2<=x1+
6
;
nx2个+=
4
) {
tryEdge(尝试边缘)
(v、x1、v2、x2、nx、nx2、nends、compgone、nsq+
1
,lines,found_func);
}
}
其他的
如果
(v[x1]>
0
&&x1%
三
==
0
) {
//
我们在一个广场上,有一个从上面进来的边缘。
//
选项1:不要继续,让它成为一个端点。
如果
(奈兹<
2
) {
//
检查组件是否正在消失。
布尔
看到了=
假
;
对于
(
整数
我=
0
;
i≤x2;
i++)
如果
(v2[i]==v[x1])=
真的
;
对于
(
整数
i=x1+
1
;
i<v。
大小
();
i++)
如果
(v[i]==v[x1])见=
真的
;
如果
(compgone+!已看到<=
1
) {
genSucc公司
(v,x1)+
1
、v2、x2、nends+
1
,compgone+!
看到了,nsq+
1
,lines,found_func);
}
}
//
选项2:添加向下的新边。
对于
(
整数
nx=x1-
6
;
nx≤x1+
6
;
nx(纳克斯)+=
4
) {
tryEdge(尝试边缘)
(v、x1、v2、x2、nx、-
1
、奈兹、康普戈内、nsq+
1
,lines,found_func);
}
}
其他的
如果
(v[x1]>
0
&&x1%
三
==
1
) {
//
必须继续向左半边。
tryEdge(尝试边缘)
(v、x1、v2、x2、x1-
1
, -
1
,nends,compgone,nsq,lines,found_func);
}
其他的
如果
(v[x1]>
0
&&x1%
三
==
2
) {
//
必须继续向右半边。
tryEdge(尝试边缘)
(v、x1、v2、x2、x1+
1
, -
1
,nends,compgone,nsq,lines,found_func);
}
其他的
{
//
在这个位置什么也做不了。
发电机成功
(v,x1)+
1
,v2,x2,nends,compgone,nsq+(v[x1]==-
1
),lines,found_func);
}
}
静止的
空隙
tryEdge(尝试边缘)
(矢量<
烧焦
>&v、,
整数
x1,矢量<
烧焦
>&v2,
整数
x2,
整数
nx、,
整数
nx2,
整数
奈兹,
整数
compgone公司,
整数
国家科学院,
成对<
整数
,
整数
>*行,函数<
空隙
(
常数
州*,
整数
)>基金会){
如果
(nx<
0
||nx>=v。
大小
())
返回
;
如果
(比较>
0
)
返回
;
//
如果组件被关闭,则不能有任何其他边。
整数
c1=v[x1];
如果
(c1==
0
)c1=v。
大小
()+
1
+x1;
//
新组件从这里开始。
如果
(nx<x2){
返回
;
//
边缘交叉。
}
其他的
如果
(nx==x2){
//
边在此点相交。
整数
c2=v2[x2];
如果
(c2==-
1
)
返回
;
//
已使用的方块。
//
将现在的两个组件连接起来。
烧焦
*二氧化碳=
无效的
;
布尔
看到=(nx2!=-
1
);
对于
(
整数
我=
0
;
i<x2;
i++){
如果
(v2[i]==c1)见=
真的
;
其他的
如果
(v2[i]==c2){c2p=&v2[i);参见=
真的
; }
}
对于
(
整数
i=x1+
1
;
i<v。
大小
();
i++){
如果
(v[i]==c1)见=
真的
;
其他的
如果
(v[i]==c2){c2p=&v[i];参见=
真的
; }
}
如果
(c2p)*c2p=c1;
v2[x2]=-
1
;
如果
(行){行->
第一
=x1;
行->
第二
=nx;
行++;}
如果
(nx2!=-
1
) {
tryEdge(尝试边缘)
(v、x1、v2、nx、nx2、-
1
,奈兹,康波恩+!
seen,nsq,lines,found_func);
}
其他的
{
genSucc公司
(v,x1)+
1
,v2,nx,nends,compgone+!
seen,nsq,lines,found_func);
}
如果
(行){行->
第一
=行->
第二
=
0
;
行--;}
v2[x2]=c2;
如果
(c2p)*c2p=c2;
}
其他的
{
v2[nx]=c1;
如果
(行){行->
第一
=x1;
行->
第二
=nx;
行++;}
如果
(nx2!=-
1
) {
tryEdge(尝试边缘)
(v、x1、v2、nx、nx2、-
1
,nends,compgone,nsq,lines,found_func);
}
其他的
{
genSucc公司
(v,x1)+
1
,v2,nx,nends,compgone,nsq,lines,find_func);
}
如果
(行){行->
第一
=行->
第二
=
0
;
行--;}
v2[nx]=
0
;
}
}
//
必要时生成成功。
空隙
生成成功
() {
如果
(已成功生成)
返回
;
成功生成=
真的
;
向量<
烧焦
>vc=v,
第2版
(v)。
大小
());
genSucc公司
(vc、,
0
,v2-
1
、奈兹、康普,
0
,
无效的
, [&] (
常数
州*st,
整数
nsq){
成功。
放回(emplace_back)
(标准->
身份证件
,nsq);
});
}
//
返回从该状态的行到给定后续状态的行的所有行的x索引。
向量<对<
整数
,
整数
>>
获取行
(
整数
succ_idx)
常数
{
向量<对<
整数
,
整数
>>
线
(
2
*(v)。
大小
(),ret;
向量<
烧焦
>vc=v,
第2版
(v)。
大小
());
genSucc公司
(vc、,
0
,v2-
1
、奈兹、康普,
0
,行(&L)[
0
], [&] (
常数
州*st,
整数
nsq){
如果
(成功ID x--==
0
)ret=线;
});
虽然
(返回。
大小
()和重试。
后面
().
第一
==
0
&&返回。
后面
().
第二
==
0
)返回。
pop_返回
();
返回
ret;
}
州
():id(
0
),ncomp公司(
0
),成功生成(
假
) {}
静止的
空隙
初始化
() {
断言
(各州。
大小
() ==
0
);
状态*结束=
新的
州
();
结束->
v(v)
.
调整大小
(NCol公司*
三
-
2
);
结束->
奈兹
=
2
;
结束->
compGone公司
=
真的
;
商店状态
(结束);
状态*开始=
新的
州
();
开始->
v(v)
.
调整大小
(NCol公司*
三
-
2
);
开始->
奈兹
=开放路径?
0
:
2
;
开始->
compGone公司
=
假
;
商店状态
(启动);
}
//
返回3个字符串,该字符串在此行和后继行之间具有电路板的ASCII表示形式。
//
前两个字符串已完全填充,但请注意,后继字符串可能不完整,因为
//
它的状态不包括向下延伸的线路。
//
'.':
未使用的棋盘格
//
“”:从上方进入一行
//
',':一行从下面进来
//
“v”:两行从上方进入
//
“^”:从下面进入两行
//
“|”:上面一行,下面一行
//
“/”:直线的中点,大致沿此方向
//
“\”:直线的中点,大致沿此方向
向量<string>
Ascii行
(
整数
succ_idx)
常数
{
向量<对<
整数
,
整数
>>行=
获取行
(succ_idx);
向量<string>
ret(雷特)
(
三
,
一串
(NCol公司*
2
-
1
,
'
'
));
对于
(
整数
我=
0
;
i<ret[
0
].
大小
();
我+=
2
)ret(雷特)[
0
][i] =ret[
2
][一]=
'
.
'
;
对于
(
整数
我=
0
;
i<v。
大小
();
我+=
三
) {
如果
(v[i]==-
1
)ret(雷特)[
0
][我/
三
*
2
] =
'
v(v)
'
;
其他的
如果
(v[i])ret[
0
][我/
三
*
2
] =
'
`
'
;
}
对于
(
整数
我=
0
;
i<线。
大小
();
i++){
整数
x=线[i]。
第一
,x2=线[i]。
第二
;
如果
(x%)
三
==
0
) {
如果
(返回[
0
][x/
三
*
2
] ==
'
`
'
)ret(雷特)[
0
][x/
三
*
2
] =
'
|
'
;
其他的
如果
(返回[
0
][x/
三
*
2
] ==
'
,
'
)ret(雷特)[
0
][x/
三
*
2
] =
'
^
'
;
其他的
ret(雷特)[
0
][x/
三
*
2
] =
'
,
'
;
}
其他的
{
如果
(x%)
三
==
1
)ret(雷特)[
0
][x/
三
*
2
+
1
] =
'
/
'
;
其他的
转塔[
0
][x/
三
*
2
+
1
] =
'
\\
'
;
}
如果
(x2%
三
==
0
) {
如果
(返回[
2
][x2个/
三
*
2
] ==
'
`
'
)ret(雷特)[
2
][x2个/
三
*
2
] =
'
v(v)
'
;
其他的
转塔[
2
][x2/
三
*
2
] =
'
`
'
;
}
其他的
{
如果
(x2%
三
==
1
)ret(雷特)[
2
][x2个/
三
*
2
+
1
] =
'
/
'
;
其他的
ret(雷特)[
2
][x2个/
三
*
2
+
1
] =
'
\\
'
;
}
如果
(x2==x+
6
)ret(雷特)[
1
][(x)+
三
)/
三
*
2
] =
'
\\
'
;
如果
(x2==x-
6
)ret(雷特)[
1
][(x)-
三
)/
三
*
2
] =
'
/
'
;
}
返回
ret;
}
一串
ToString(目标字符串)
()
常数
{
鸵鸟流汤;
苏特<<
'
{
'
;
对于
(
整数
我=
0
;
i<v。
大小
();
我+=
三
) {
sout<<(
整数
)v[i];
如果
(i)+
1
<v。
大小
()) {
苏特<<
'
<
'
<< (
整数
)v[i+
1
] <<
'
,
'
<< (
整数
)v[i+
2
] <<
'
>
'
;
}
}
苏特<<
"
结束=
"
<< (
整数
)嫩枝;
如果
(compGone)汤<<
"
完成
"
;
苏特<<
'
}
'
;
返回
苏特。
字符串
();
}
朋友
鸵鸟&
操作人员
<<(ostream和out,
常数
状态(&S){
输出<<标准。
ToString(目标字符串)
();
返回
出局;
}
};
向量<状态*>状态::状态;
空隙
生成所有状态
() {
对于
(
整数
我=
0
;
i<州::州。
大小
();
i++)状态::状态[i]->
生成成功
();
cout公司<<
"
总计:
"
<<状态::状态。
大小
() <<
"
状态。
"
<<endl;
}
空隙
打印所有成功
() {
对于
(
整数
我=
0
;
i<州::州。
大小
();
i++){
cout公司<<
"
的继任者#
"
<<i<<
"
"
<<*状态::状态[i]<<
"
:
"
<<endl<<endl;
对于
(
整数
j个=
0
;
j<状态::状态[i]->
成功
.
大小
();
j++){
vector<string>v=状态::状态[i]->
AsciiRow公司
(j) ;
cout公司<<
'
|
'
<<v[
0
] <<
'
|
'
<<endl;
cout公司<<
'
|
'
<<v[
1
] <<
"
| +
"
<<状态::状态[i]->
成功
[j] ●●●●。
第二
;
如果
(状态::状态[状态::州[i]->
成功
[j] ●●●●。
第一
]->
compGone公司
)cout公司<<
"
完成
"
;
cout<<endl;
cout公司<<
'
|
'
<<v[
2
] <<
'
|
'
<<endl;
cout<<endl;
}
}
}
//
使用给定的解决方案打印棋盘。
//
州应满足id[0]==1,id[nrows]==0,每个suc[idx[i]]指向id[i+1]。
空隙
PrintOne解决方案
(
常数
向量<
整数
>&id,
常数
向量<
整数
>&idx){
cout公司<<
'
'
<<
一串
(NCol公司*
2
-
1
,
'
-
'
) <<
'
'
<<endl;
对于
(
整数
我=
0
;
我+
1
<同上。
大小
();
i++){
vector<string>v=状态::状态[id[i]]->
AsciiRow公司
(idx[i]);
cout公司<<
'
|
'
<<v[
0
] <<
'
|
'
<<endl;
如果
(i)+
2
<同上。
大小
()cout<<
'
|
'
<<v[
1
] <<
'
|
'
<<endl;
}
cout公司<<
'
'
<<
一串
(NCol公司*
2
-
1
,
'
-
'
) <<
'
'
<<endl;
}
//
将给定的解决方案输出到文件“open[col]x[row].svg”。
//
如果指定,则突出显示从minHL到maxHL的行。
空隙
写入解决方案SVG
(
常数
向量<
整数
>&id,
常数
向量<
整数
>&idx、,
整数
最小HL=-
1
,
整数
最大HL=-
1
) {
整数
x=NCol,y=id。
大小
()-
1
;
整数
平方=
15
;
//
正方形的大小(像素)
烧焦
fn公司[
100
];
把格式数据写成串
(fn,
"
%s%dx%d.svg
"
,OpenPaths?
"
打开
"
:
"
关闭
"
、x、y);
文件输出流
福特
(fn);
福特<<
"
<?
xml版本=
\"
1
\"
编码=
\"
UTF-8型
\"
?>
\n个
"
;
福特<<
"
<svg xmlns=
\"
http://www.w3.org/2000/svg
\"
版本=
\"
1.1
\"
>
\n个
"
;
福特<<
"
<模式id=
\"
棋盘
\"
x个=
\"
5
\"
年=
\"
5
\"
"
;
福特<<
"
宽度=
\"
"
<<平方*
2
<<
"
\"
高度=
\"
"
<<平方*
2
<<
"
\"
pattern单位=
\"
使用中的用户空间
\"
>
\n个
"
;
福特<<
"
<矩形填充=
\"
rgba(1591881910.4)
\"
x个=
\"
0
\"
年=
\"
0
\"
"
;
福特<<
"
宽度=
\"
"
<<平方<<
"
\"
高度=
\"
"
<<平方<<
"
\"
/>
\n个
"
;
福特<<
"
<矩形填充=
\"
rgba(1591881910.4)
\"
x个=
\"
"
<<平方<<
"
\"
年=
\"
"
<<平方<<
"
\"
"
;
福特<<
"
宽度=
\"
"
<<平方<<
"
\"
高度=
\"
"
<<平方<<
"
\"
/>
\n个
"
;
福特<<
"
</pattern>
\n个
"
;
福特<<
"
<矩形填充=
\"
url(#棋盘格)
\"
x个=
\"
5
\"
年=
\"
5
\"
"
;
福特<<
"
宽度=
\"
"
<<sq*x<<
"
\"
高度=
\"
"
<<平方*年<<
"
\"
"
;
犯规<<
"
风格=
\"
冲程宽度:2;
冲程:rgb(150150230)
\"
/>
\n个
"
;
向量<向量<
布尔
>>
习惯于
(y,矢量<
布尔
>(x) );
对于
(
整数
第页=
0
;
第页+
1
<年;
r++){
向量<对<
整数
,
整数
>>lines=状态::状态[id[r]]->
获取行
(idx[r]);
对于
(
汽车
线条:线条){
双重的
x1=(线。
第一
/
三
)+(线路。
第一
%
三
!=
0
) *
0.5
;
双重的
x2=(线。
第二
/
三
)+(线路。
第二
%
三
!=
0
) *
0.5
;
如果
(x1==(
整数
)x1)使用[r][x1]=
真的
;
如果
(x2==(
整数
)x2)使用[r+
1
][x2]个=
真的
;
福特<<
"
<线x1=
\"
"
<<
5
+x1*sq+sq/
2
<<
"
\"
y1个=
\"
"
<<
5
+r*sq+sq/
2
<<
"
\"
"
;
福特<<
"
2个=
\"
"
<<
5
+x2*平方+平方/
2
<<
"
\"
第2年=
\"
"
<<
5
+(r)+
1
)*平方+平方/
2
<<
"
\"
"
;
福特<<
"
风格=
\"
笔划:rgb(0,0,0);
冲程宽度:1
\"
/>
\n个
"
;
}
}
对于
(
整数
第页=
0
;
r<y;
r++)
对于
(
整数
c(c)=
0
;
c<x;
c++)
如果
(!使用了[r][c]){
福特<<
"
<圆形填充=
\"
rgb(255,0,0)
\"
"
<<
"
cx公司=
\"
"
<<
5
+c*sq+sq/
2
<<
"
\"
连续性=
\"
"
<<
5
+r*sq+sq/
2
<<
"
\"
第页=
\"
1
\"
/>
\n个
"
;
}
如果
(最小HL!=-
1
) {
福特<<
"
<矩形填充=
\"
没有人
\"
x个=
\"
2
\"
年=
\"
"
<<
2
+minHL*平方+平方/
2
<<
"
\"
"
;
福特<<
"
宽度=
\"
"
<<
6
+x平方<<
"
\"
高度=
\"
"
<<(maxHL-minHL)*sq<<
"
\"
"
;
福特<<
"
冲程仪表=
\"
7, 7
\"
风格=
\"
冲程宽度:2;
冲程:rgb(250150250)
\"
/>
\n个
"
;
}
福特<<
"
</svg>
\n个
"
;
}
空隙
查找一个解决方案和周期
() {
向量<向量<
整数
>>
最大路径(_P)
(N低+
1
,矢量<
整数
>(州::州。
大小
(), -
1
));
向量<向量<
整数
>>
pred(前)
(N低+
1
,矢量<
整数
>(州::州。
大小
(), -
1
));
向量<向量<
整数
>>
pred_idx前
(N低+
1
,矢量<
整数
>(州::州。
大小
(), -
1
));
向量<向量<
整数
>>
nsol公司
(N低+
1
,矢量<
整数
>(州::州。
大小
(),
0
));
最大路径(_P)[
0
][
1
] =
0
;
nsol公司[
0
][
1
] =
1
;
整数
发现周期=-
1
,发现_添加=-
1
,发现n=-
1
;
对于
(
整数
行=
1
;
行<=NRow;
行++){
对于
(
整数
我=
0
;
i<州::州。
大小
();
i++)
如果
(最大路径[行-
1
][i] >=
0
)
对于
(
整数
j个=
0
;
j<状态::状态[i]->
成功
.
大小
();
j++){
整数
nst=状态::状态[i]->
成功
[j] ●●●●。
第一
;
整数
ne=州::州[i]->
成功
[j] ●●●●。
第二
;
如果
(最大路径[行-
1
][i] +ne>最大路径[row][nst]){
max_path[row][nst]=最大路径[row-
1
][i] +ne;
pred[row][nst]=i;
pred_idx[row][nst]=j;
nsol[row][nst]=nsol[rouw-
1
][i] ;
}
其他的
如果
(最大路径[行-
1
][i] +ne==最大路径[row][nst]){
nsol[row][nst]+=nsol[rouw-
1
][i] ;
}
}
cout<<endl;
cout<<NCol<<
"
x个
"
<<行<<
"
:
"
<<最大路径[行][
0
];
cout公司<<
"
(
"
<<nsol[行][
0
] <<
"
解决方案)
"
<<endl;
如果
(最大路径[行][
0
] != -
1
) {
向量<
整数
>
st_id(st_id)
(行+
1
),
st_idx
(行+
1
);
对于
(
整数
r=行,st=
0
,idx=-
1
;
r>(r)=
0
;
idx=pred_idx[r][st],st=pred[r][st],r--){
st_id[r]=st;
st_idx[r]=idx;
}
PrintOne解决方案
(st_id,st_idx);
//
尝试用一种天真的方法来寻找周期性。
整数
期间,已添加,开始;
对于
(期间=
1
;
周期<st_id。
大小
();
周期++){
已添加=-
1
;
对于
(
整数
我=
0
;
i+周期<st_id。
大小
();
i++)
如果
(st_id[i]==st_id[i+句点]){
整数
当前添加(_A)=
0
;
对于
(
整数
j个=
0
;
j<周期;
j++){
cur_added+=状态::状态[st_id[i+j]]->
成功
[st_idx[i+j]]。
第二
;
}
如果
(cur_added>added){added=cur_aadded;start=i;}
}
如果
(添加!=-
1
) {
//
我们有一个潜在的模式:我们可以添加“added”的每个“period”行。
//
我们可以通过回顾“周期”行来证明这是最优的
//
没有哪个州的得分超过“加分”。
布尔
最佳的=
真的
;
对于
(
整数
我=
0
;
i<最大路径[行]。
大小
();
i++){
如果
((最大路径[row][i]!=-
1
)^(最大路径[行周期][i]!=-
1
)){最佳=
假
;
打破
; }
如果
(最大路径[row][i]==-
1
)
持续
;
如果
(最大路径[行周期][i]+添加<最大路径[行][i]){最佳=
假
;
打破
; }
}
如果
(最佳)
打破
;
}
}
如果
(周期<st_id。
大小
()) {
写入解决方案SVG
(st_id,st_idx,开始,开始+周期);
}
其他的
{
写入解决方案SVG
(st_id,st_idx);
}
如果
(周期<st_id。
大小
()) {
cout<<NCol<<
"
x个
"
<<行<<
"
:重复优化模式,周期
"
<<周期;
cout公司<<
"
,平均得分
"
<< (
双重的
)添加/周期<<endl;
cout公司<<
"
排
"
<<开始<<
"
到
"
<<开始+周期<<
"
可以重复,添加
"
<<添加<<
"
.
"
<<endl;
如果
(创建周期!=-
1
&&发现周期%周期==
0
&&已添加*(found_period/period)==已创建(已添加){
found_n++;
}
其他的
{
found_period=周期;
found_added=已添加;
发现n=
1
;
}
如果
(发现n==发现周期){
//
尽可能简化周期部分
周期=基础周期;
added=创建添加;
向量<
整数
>v;
对于
(
整数
第页=
0
;
r<=行;
r++)版本。
推回(_B)
(最大路径[r][
0
]);
对于
(
整数
我=
0
;
i<周期;
i++)版本。
推回(_B)
(v[v。
大小
()-期间]+新增);
对于
(
整数
分区
=
2
;
分区
<=周期;
分区
++)
如果
(期间%
分区
==
0
&&已添加%
分区
==
0
) {
整数
i;
对于
(i)=
0
;
i<周期-周期/
分区
;
i++){
如果
(v[v。
大小
()-添加了句点+i]+/
分区
!=
v【v】。
大小
()-句点+i+句点/
分区
])
打破
;
}
如果
(i==周期/
分区
) {
周期/=
分区
;
已添加/=
分区
;
分区
--;
}
}
虽然
(v)。
大小
() >
2
*周期&&
v【v】。
大小
()-
1
-周期。
大小
()-
1
]-已添加&&
v【v】。
大小
()-
1
-
2
*周期]==v[v。
大小
()-
1
] -
2
*已添加){
(v)。
pop_返回
();
//
尽可能压缩周期部分
}
cout公司<<
"
发现的完整旋转
"
<<周期<<
"
时期。
正在终止搜索。
"
<<endl;
cout公司<<
"
C类=
"
<<NCol<<
"
:
"
;
对于
(
整数
第页=
1
;
r<v。
大小
();
r++){
cout公司<<
'
'
;
如果
(r==v。
大小
()-
2
*周期r==v。
大小
()-句点)cout<<
'
[
'
;
cout<<v[r];
如果
(r==v。
大小
()-
1
-周期r==v。
大小
()-
1
)cout公司<<
'
]
'
;
cout公司<<
'
,
'
;
}
cout公司<<
"
...
"
<<endl;
返回
;
}
}
其他的
{
发现周期=-
1
;
}
}
}
}
整数
主要的
(
整数
argc、,
烧焦
*argv[]){
如果
(argc>
1
)
sscanf公司
(argv(argv))[
1
],
"
%d日
"
,&NCol);
如果
(argc>
2
)
sscanf公司
(argv(argv))[
2
],
"
%d日
"
,&N低);
如果
(argc>
三
)OpenPaths=!
字符串比较函数
(argv(argv))[
三
],
"
打开
"
);
cout公司<<
"
解决
"
<<NCol<<
"
柱,
"
;
cout<<(开放路径?
"
打开
"
:
"
关闭
"
) <<
"
路径。
"
<<endl;
状态::初始化
();
生成所有状态
();
查找一个解决方案和周期
();
}
此时无法执行该操作。