// 起点开始搜索
int dfs_large(int id, bool inload[], int cnt, int &best_cost, bool flag = false)
{
//cout << "dfs(" << id << "," << cnt << ")" << endl;
if(id == eid)
{
best_cost = update_ans(ans_sum,ans);
//update_good(ans_sum,ans);
return FIND_SOLVE;
}
if(is_timeout())
{
return TIME_OUT; // time out
}
// start bfs
int (&last)[MAX_NODE_NUM] = g_last[cnt];
int (&w)[MAX_NODE_NUM] = g_w[cnt];
int (&dis)[MAX_NODE_NUM] = g_dis[cnt];
for(int i=0;i<node_size;i++)
{
last[i] = w[i] = dis[i] = -1;
}
int (&que)[MAX_NODE_NUM] = g_que[cnt];
int front = 0;
int rear = 0;
int find_cnt = 0;
int find_cnt_limit = find_cnt_up;
if(cnt == must_node_cnt)
find_cnt_limit = 3;
if(cnt == 1)
find_cnt_limit = node_size*8;
w[id] = 0;
dis[id] = 0;
que[rear++] = id;
// 只剩下最后一个节点 , spfa
if(cnt == 0)
{
int que_tag[MAX_NODE_NUM] = {0};
que_tag[id] = true;
while(front != rear)
{
int now_id = que[front++];
if(front == MAX_NODE_NUM)
front = 0;
for(int i=0; i<node_next[now_id].size(); i++)
{
int r_node = edge_set[node_next[now_id][i]].r;
if(inload[r_node])
continue;
if(w[r_node] == -1 || w[now_id] + edge_set[node_next[now_id][i]].cost < w[r_node])
{
w[r_node] = w[now_id] + edge_set[node_next[now_id][i]].cost;
last[r_node] = now_id;
if(!que_tag[r_node])
{
que_tag[r_node] = true;
que[rear++] = r_node;
if(rear==MAX_NODE_NUM)
rear = 0;
}
}
}
que_tag[now_id] = false;
}
if(w[eid] == -1)
return cnt+1;
int t_ans_sum = ans_sum;
vector<int> load_nodes;
load_nodes.push_back(eid);
int tmp_id = eid;
while(last[tmp_id] != -1)
{
tmp_id = last[tmp_id];
load_nodes.push_back(tmp_id);
}
reverse(load_nodes.begin(),load_nodes.end());
for(int i=0;i<load_nodes.size();i++)
{
//inload[load_nodes[i]] = true;
if(i < load_nodes.size() - 1)
{
add_edge(load_nodes[i],load_nodes[i+1],ans_sum,ans);
}
}
best_cost = update_ans(ans_sum,ans);
//update_good(ans_sum,ans);
ans_sum = t_ans_sum;
return FIND_SOLVE;
}
int fin_res = cnt;
int t_best_cost = 2000000;
while(front < rear && find_cnt < find_cnt_limit)
{
if(cnt >= must_node_cnt - 5 && front > 0 && w[que[front]] != w[que[front-1]])
{
vector<pair<int,int> > pp;
for(int i=front;i<rear;i++)
pp.push_back(MP(dis[que[i]],que[i]));
sort(pp.begin(),pp.end());
for(int i=front;i<rear;i++)
que[i] = pp[i-front].second;
}
int now_id = que[front++];
for(int i=0; i<node_next[now_id].size(); i++)
{
int r_node = edge_set[node_next[now_id][i]].r;
if(inload[r_node] || w[r_node] != -1)
continue;
if(must_node[r_node] || (cnt == 0 && r_node == eid) )
{
int t_ans_sum = ans_sum;
//vector<int> load_nodes;
vector<int> edge_nodes;
//load_nodes.push_back(r_node);
//load_nodes.push_back(now_id);
edge_nodes.push_back(node_next[now_id][i]);
int tmp_id = now_id;
while(last[tmp_id] != -1)
{
tmp_id = last[tmp_id];
//load_nodes.push_back(tmp_id);
edge_nodes.push_back(tmp_id);
tmp_id = edge_set[tmp_id].l;
}
reverse(edge_nodes.begin(),edge_nodes.end());
for(int i=0;i<edge_nodes.size();i++)
{
//inload[load_nodes[i]] = true;
inload[edge_set[edge_nodes[i]].r] = true;
/*
if(i < load_nodes.size() - 1)
{
add_edge(load_nodes[i],load_nodes[i+1],ans_sum,ans);
}
*/
ans[ans_sum++] = edge_nodes[i];
}
find_cnt ++;
int t_t_best_cost = 2000000;
int res = dfs_large(r_node, inload, cnt - 1, t_t_best_cost, flag);
//find_cnt --;
t_best_cost = min(t_best_cost,t_t_best_cost);
best_cost = min(t_best_cost,best_cost);
ans_sum = t_ans_sum;
for(int i=0;i<edge_nodes.size();i++)
{
inload[edge_set[edge_nodes[i]].r] = false;
}
if(res == END_OUT)
return res;
fin_res = min(res, fin_res);
int min_l = 8;
int min_g = 8;
if(!flag)
{
if(good_cost < INF_COST)
{
min_l = 5;
min_g = 13;
}
if(cnt > min_l && cnt < must_node_cnt - min_g)
return fin_res;
//else if((cnt > min_l) && cnt < must_node_cnt - min_g + 3 && (fin_res > 0 || t_best_cost - 20 > good_cost))
else if(cnt > min_l - 1 && cnt < must_node_cnt - min_g + 5 && (fin_res > 0 || t_best_cost - 3 > good_cost))
return fin_res;
}
else
{
min_l = 6;
min_g = 10;
if(must_node_cnt > 22)
{
min_l = 8;
min_g = 10;
}
if(good_cost < INF_COST)
{
if(node_size >= 300)
{
min_l = 6;
min_g = 12;
}
else
{
min_l = 6;
min_g = 10;
}
if(must_node_cnt > 22)
{
min_l = 8;
min_g = 6;
}
}
if(cnt > min_l && cnt < must_node_cnt - min_g )//&& t_best_cost > good_cost)
return fin_res;
else if(cnt < must_node_cnt - min_g - 2 && (t_best_cost - 3 > good_cost || cnt > 0) )
return fin_res;
}
}
else
{
w[r_node] = w[now_id] + 1;
dis[r_node] = dis[now_id] + edge_set[node_next[now_id][i]].cost;
//last[r_node] = now_id;
last[r_node] = node_next[now_id][i];
que[rear++] = r_node;
}
}
}
return fin_res;
}
//你要完成的功能总入口
void search_route(char *topo[5000], int edge_num, char *demand)
{
start_time = get_now_time();
read_topo(topo);
read_demand(demand);
if((node_size<=100) || node_size > 500)
{
int tmp_up = find_cnt_up + 2;
bool flag = false;
if(node_size<=500)
{
flag = true;
}
if(node_size <= 100) // 顶点小于100搜一次即可
{
find_cnt_up = 4;
tmp_up = find_cnt_up+1;
}
else if(must_node_cnt < 15)
{
tmp_up++;
find_cnt_up++;
}
//if(node_size >= 200)
// tmp_up += 5;
cout << "flag:" << flag << endl;
while(find_cnt_up < tmp_up) //&& good_cost < last_cost)
{
//last_cost = good_cost;
bool tag[MAX_NODE_NUM] = {0};
int cnt = must_node_cnt;
tag[sid] = true;
int now_time = get_now_time();
int res,tb;
if(node_size>=100 && node_size<150)
res = dfs(sid,tag,cnt,tb);
else res = dfs_large(sid,tag,cnt,tb,flag);
if(res == END_OUT)
break;
cout << "find res : " << res << endl;
find_cnt_up++;
}
}
else
{
lp_solver(sid,eid,edge_cnt,edge_set,node_size,must_node,ans_sum,ans,node_next);
update_ans(ans_sum,ans);
}
//cout << ans_sum << endl;
cout << "route_len: " << good_sum << endl;
cout << "good_cost: " << good_cost << endl;
for (int i = 0; i < good_sum; i++)
{
if (0 == i)
//cout << edge_set[ans[i]].edge_id;
cout << good_ans[i];
else cout<< "|" << good_ans[i];
record_result(edge_set[good_ans[i]].edge_id);
}
cout << endl;
end_time = get_now_time();
cout << "used time : " << (end_time - start_time) << endl;
}
vector<vector<int>> palindromePairs(vector<string>& words)
{
ans.clear();
check_rep.clear();
tot = words.size();
ori_map.clear();
for (int i=0;i<words.size();++i)
ori_map.emplace(words[i], i);
vector<string> rev(words);
rev_map.clear();
for (int i=0;i<rev.size();++i)
{
reverse(rev[i].begin(), rev[i].end());
rev_map.emplace(rev[i],i);
}
set<int> pal_set;
string tmp;
for (int i=0;i<words.size();++i)
{
pal_set.clear();
pal_set = manacher(words[i]);
// printf("Word %d palindrome suffix: ",i);
// for (set<int>::iterator it = pal_set.begin(); it != pal_set.end(); ++it)
// printf("%d ", *it);
// printf("\n");
const string &cur = words[i];
tmp = "";
for (int j=0;j<cur.length();tmp+=cur[j++])
{
if (pal_set.find(cur.length()-j) != pal_set.end() && rev_map.find(tmp) != rev_map.end())
update_ans(i, rev_map[tmp]);
}
if (rev_map.find(tmp) != rev_map.end()) update_ans(i, rev_map[tmp]);
}
for (int i=0;i<words.size();++i)
{
pal_set = manacher(rev[i]);
// printf("Word %d palindrome prefix: ",i);
// for (set<int>::iterator it = pal_set.begin(); it != pal_set.end(); ++it)
// printf("%d ", *it);
// printf("\n");
const string &cur = words[i];
tmp = "";
for (int j=cur.length(); j>0; tmp+=cur[--j])
{
// cout << j<< ":" << tmp << endl;
if (pal_set.find(j) != pal_set.end() && ori_map.find(tmp) != ori_map.end())
update_ans(ori_map[tmp], i);
}
if (ori_map.find(tmp) != ori_map.end()) update_ans(ori_map[tmp],i);
}
return ans;
}
