2019年2月

正则删除关键字所在行

查找:

^.*大师兄.*$
替换为:(空)

如果不留空行:
查找:

^.*大师兄.*\r?\n

替换为:(空)

正则删除HTML标签

Ctrl + H 正则匹配 <[^>]+> 替换为空

正则替换换行

Ctrl + H 正则匹配 \n 替换为你想要的

好好学习

每天花大把时间在微信上,但其实有没有什么重要的事情。仔细统计了一下,如果我一天不看微信,每天至少可以多出1-3h。每次都高估了自己被世界需要的可能性。没看手机时,以为全世界都在找我,看手机时发现没人关注我。

预备,晚上

今晚会不会有人发现我不在了?一想到要坚持三天就感觉有点困难。

第一天

正常

第二天

由于不可抗力,该计划被迫终止。

目前,我采用的是迪杰斯特拉算法计算所有点的最短路径(感觉弗洛伊德算法会更好些?)。迪杰斯特拉算法算的是单源(V_begin)到所有点的最短距离,也就是说需要遍历一次所有的点。

遍历V_begin

for (int V_begin = 0; V_begin < G->m_CrossRoad_v.size(); V_begin++) {
}
下面是迪杰斯特拉算法的流程

1. 声明dist数组

vector<double> Determined_dist(G->m_CrossRoad_v.size(), 0.0);

2. 初始化顶点集

void calcShortestPath(Graph *G) {
    int currentPointSite,nextPointSite;
    ofstream PointPathFile(DIR_RES"PointPath.txt"),RoadPathFile(DIR_RES"RoadPath.txt");
    //对点进行的一级遍历
    for (int V_begin = 0; V_begin < G->m_CrossRoad_v.size(); V_begin++) {
        // =================== 迪杰斯特拉算法开始 ===============================
        vector<bool> S(G->m_CrossRoad_v.size(), false); //判断是否选中
        vector<double> dist(G->m_CrossRoad_v.size(), DBL_MAX/2);// dist
        vector<double> compare_dist(G->m_CrossRoad_v.size(), DBL_MAX/2);// 辅助dist用来取最短距离点
        vector<int> path(G->m_CrossRoad_v.size(),-2); // path
        S[V_begin] = true;
        path[V_begin] = -1;
        for(auto crossroad : G->m_CrossRoad_v[V_begin].JunctionRoad){
            nextPointSite = G->m_Road_v[crossroad.outRoadID].m_CrossRoadToSite;
            dist[nextPointSite] = G->m_Road_v[crossroad.outRoadID].m_dLength;
            compare_dist[nextPointSite] = dist[nextPointSite];
        }
        auto min = min_element(compare_dist.begin(), compare_dist.end());
        int min_element_index = distance(compare_dist.begin(), min);
        compare_dist[min_element_index] = DBL_MAX/2;
        // 循环size-1次
        for(int i = 0; i < G->m_CrossRoad_v.size()-1; i++){
            for(auto crossroad : G->m_CrossRoad_v[min_element_index].JunctionRoad){
                currentPointSite = min_element_index;
                nextPointSite = G->m_Road_v[crossroad.outRoadID].m_CrossRoadToSite;
                if(S[nextPointSite]){
                    continue;
                }
                if(dist[nextPointSite] > dist[currentPointSite] + G->m_Road_v[crossroad.outRoadID].m_dLength) {
                    dist[nextPointSite] = dist[currentPointSite] + G->m_Road_v[crossroad.outRoadID].m_dLength;
                    compare_dist[nextPointSite] = dist[nextPointSite];
                    path[nextPointSite] = currentPointSite;
                }
            }
            min = min_element(compare_dist.begin(), compare_dist.end());
            min_element_index = distance(compare_dist.begin(), min);
            S[min_element_index] = true;
            compare_dist[min_element_index] = DBL_MAX/2;
        }
        for(int i = 0;i<path.size();i++){
            int j = i;
            bool flag = false;
            while( path[j] >= 0) {
                flag = true;
                PointPathFile << path[j] << " ";
                for(auto node:G->m_CrossRoad_v[j].JunctionRoad){
                    if(G->m_Road_v[node.outRoadID].m_CrossRoadToSite == path[j]){
                        RoadPathFile << node.outRoadID << " ";
                    }
                }
                j = path[j];
            }
            if(flag){RoadPathFile << endl;PointPathFile << endl ;}
        }
    }
}

runSimulation(Graph &G)

1. 遍历每条道路

2. 遍历该道路的车辆

a. 计算特定时间间隔后的位置

b. 若应行驶至其他道路

进入对应的路口缓冲区,根据路口类的红绿灯对象判断是否能通行。

若能通行,则填至目标道路

若不能,则继续停留在路口缓冲区

c. 若仍停留在原道路

改变该车在当前道路的位置。

  for (auto &road:G.m_Road_v) {
        auto src = road.m_queVehicle;
        decltype(road.m_queVehicle) obj;
        //路内车的遍历
        while (!src.empty()) {
            //弹出一辆车
            auto it = src.front();
            src.pop_front();
            // 当车的时间戳小于实际时间时,才模拟运行
            if (it.time < SYSTEM_TIME) {
                it.fSpec = (100 - road.get_Congestion() - 20) / 3.6;
                dist = it.dDistance + it.fSpec * 10;
                it.time++;

                it.showself();
                //如果车十秒后不在此路
                if (dist >= road.m_dLength) {
                    //路径擦除
                    auto route = it.queRoute;
                    int site = it.m_nSiteRoadID;
                    route.pop();
                    //如果抵达终点
                    if (route.empty()) {
                        cout << "it is be shutdown" << endl;
                        exit(0);
                        // 否侧没有抵达终点
                    } else {
                        //获取所在路和下一条路的ID
                        int next = route.front();
                        //判断红绿灯情况
                        cout << site << endl;
                        G.m_CrossRoad_v[site].m_CTrafficLight_Light.clock(SYSTEM_TIME);
                        //如果可以通行
                        if (G.m_CrossRoad_v[site].m_CTrafficLight_Light.getStatus(it.m_nSiteRoadID, next)) {
                            cout << GREEN << "绿灯通行:" << endl;
                            it.queRoute = route;
                            it.dDistance = 0;
                            it.m_nSiteRoadID = next;
                            auto *site_road = &G.m_Road_v[next].m_queVehicle;
                            site_road->push_back(it);
                            //如果不能通行
                        } else {
                            //将距离置为道路长度,表示正在等候红灯
                            it.dDistance = G.m_Road_v[it.m_nSiteRoadID].m_dLength;
                            cout << YELLOW << "等待红灯" << endl;
                            //车辆塞回去
                            obj.push_back(it);
                        }
                    }
                    //否则,当车十秒后还在此路时
                } else {
                    it.dDistance = dist;
                    obj.push_back(it);
                }
                //否则直接填入
            } else {
                obj.push_back(it);
            }
        }
        road.m_queVehicle = obj;
    }

generateVehicle(Map_Graph);

1. 随机车辆总数

  • [ ] 此处未随机,待完善
std::random_device rd;
std::mt19937 mt(rd());

2. 遍历车辆,为车辆设立起点和路线

a. 在道路向量中随机选一条路径

-[ ] 此处未随机,待完善

auto route = v_Route[3];

b. 以该路径的首序列为起点

Vehicle car(n_VehicleNum, route, 0, 0, route.front());
G.m_Road_v[route.front()].m_queVehicle.push_back(car);