C++ Conditions类代码示例

void PrintConditions(int source, int dest, const Conditions & conditions) {
    printf("------------------------------约束条件如下：\n");
    printf("起点： 「%d」， 终点： 「%d」\n", source, dest);
    printf("必须经过的点：");
    bool firstBlood = false;
    for(Conditions::const_iterator iter = conditions.begin(); iter != conditions.end(); ++iter) {
        if(firstBlood)
            printf("|");
        printf("%d", *iter);
        firstBlood = true;
    }
    printf("\n");
}

// RIDMap map<string, RIDList>
// RIDTree map<string, ValueMap>
bool Domain::Indices::Lookup(const set<string>& dimensions,
														 const Conditions& conditions, 
														 Data::RIDTree& results) {
	
	ValuesMap values;
	if(!this->meta->index->OpenReader()) { return false; }
	if(!this->meta->index->Lookup(dimensions, values)) { 
		this->meta->index->Close(); return false; 
	}
	
	Data::RIDMap records;
	ValuesMap::iterator vlist;
	for(vlist = values.begin(); vlist != values.end(); vlist++) {
		sort(vlist->second.begin(), vlist->second.end());
		conditions.Apply(vlist->first, vlist->second);
		
		if(!this->meta->index->Lookup(vlist->first, vlist->second, records)) { 
			this->meta->index->Close();
			return false;
		} else {
			results[vlist->first] = records;
		}
	}
	
	this->meta->index->Close();
	
	return true;
}

uint KSpread::qHash(const Conditions &c)
{
    uint res = 0;
    foreach (const Conditional& co, c.conditionList()) {
        res ^= qHash(co);
    }
    return res;
}

void ReadConditionsData(char *conditionsStream, int & source, int & dest, Conditions & conditions) {
    int i = 0;
    source = ReadANumberFromStr(conditionsStream, i);
    dest = ReadANumberFromStr(conditionsStream, i);
    while(conditionsStream[i] != '\0') {
        conditions.insert(ReadANumberFromStr(conditionsStream, i));
    }
}

//--------------------------------------------------------------------------------------------------------赛题入口
void search_route(char *graphStream[5000], int edge_num, char *conditionsStream)
{
    Graph graph;
    EdgeInfoDict edgeInfoDict;
    int source;
    int dest;
    Conditions conditions;
    ShortestPathDict pathDict;
    SK66_D_dict ddict;
    SK66_F_dict fdict;

    ReadGraphData(graphStream, graph, edgeInfoDict);                 // read a.csv
    ReadConditionsData(conditionsStream, source, dest, conditions);  // read b.csv

//    std::set<int> without;
//    without.insert(1);
//    without.insert(2);




    SK66(source, source, dest, conditions.size(), graph, edgeInfoDict, conditions, ddict, fdict, pathDict);

    std::pair<std::pair<int, int>, int> key;
    key.first.first = source;
    key.first.second = dest;
    key.second = conditions.size();
    Path ansPath = fdict[key];
    int ansCost = ansPath.first;
    std::vector<int> & pointPath = ansPath.second.first;
    std::vector<int> & edgePath = ansPath.second.second;

    printf("路径花费 == %d\n", ansCost);
    printf("共经过了「%d」个结点： ",pointPath.size());
    for(std::vector<int>::const_iterator iter = pointPath.begin(); iter != pointPath.end(); ++iter)
        printf("%d|", (*iter));
    printf("\n");
    printf("共经过了「%d」条边: ", edgePath.size());
    for(std::vector<int>::const_iterator iter = edgePath.begin(); iter != edgePath.end(); ++iter)
        printf("%d|", (*iter));
    printf("\n");
}

void Conditions::add(const Conditions& cdts)
{
    std::for_each(cdts.conditionlist().begin(), cdts.conditionlist().end(),
                  AddCondition(*this));
}

void SK66(
        int node,
        int source,
        int dest,
        int iterCount,
        const Graph & graph,
        const EdgeInfoDict & edgeInfoDict,
        const Conditions & conditions,
        SK66_D_dict & ddict,
        SK66_F_dict & fdict,
        ShortestPathDict & pathDict) {
    // 当迭代次数为0时， 直接计算node->dest单源最短路径，存入结果字典里
    if(iterCount == 0) {
        std::pair<int, int> pathToBeSolve(node, dest);
        if(!pathDict.count(pathToBeSolve))
            Dijkstra(graph, edgeInfoDict, node, pathDict);
        if(!pathDict.count(pathToBeSolve)) {
            std::pair<std::pair<int, int>, int> key;
            key.first = pathToBeSolve;
            key.second = 0;
            Path path;
            path.first = 0xffffff;          // 六个f， 足够表示无穷大了, 防止在后续加法中溢出
            fdict[key] = path;
        } else {
            std::pair<std::pair<int, int>, int> key;
            key.first = pathToBeSolve;
            key.second = 0;
            ShortestPathDict::const_iterator PPath = pathDict.find(pathToBeSolve);
            Path path = PPath->second;
            fdict[key] = path;
        }
    } else {
        // 当迭代次数大于0的时候
        std::pair<std::pair<int, int>, int> key;
        key.first = std::pair<int, int>(node, dest);
        key.second = iterCount;

        Path minCostPath;
        minCostPath.first = 0x7fffffff;

        for(Conditions::const_iterator iter = conditions.begin(); iter != conditions.end(); ++iter) {
            if(*iter == node)
                continue;

            // 计算D(v_i, v_l)
            std::pair<int, int> leftHalfPathToBeSolve(node, *iter);
            if(!pathDict.count(leftHalfPathToBeSolve)) {
                Dijkstra(graph, edgeInfoDict, node, pathDict);
            }
            if(!pathDict.count(leftHalfPathToBeSolve)) {
                Path leftHalfPath;
                leftHalfPath.first = 0xffffff;
                ddict[leftHalfPathToBeSolve] = leftHalfPath;
            } else {
                ShortestPathDict::const_iterator PPath = pathDict.find(leftHalfPathToBeSolve);
                Path leftHalfPath = PPath->second;
                ddict[leftHalfPathToBeSolve] = leftHalfPath;
            }
            // 计算F(v_l, t)





            // 筛选出最小值
            std::pair<std::pair<int, int>, int> rightHalfPathToBeSolve;
            rightHalfPathToBeSolve.first.first = *iter;
            rightHalfPathToBeSolve.first.second = dest;
            rightHalfPathToBeSolve.second = iterCount-1;
            if(!fdict.count(rightHalfPathToBeSolve)) {
                SK66(*iter, source, dest, iterCount-1, graph, edgeInfoDict, conditions, ddict, fdict, pathDict);
            }
            if(ddict[leftHalfPathToBeSolve].first + fdict[rightHalfPathToBeSolve].first < minCostPath.first) {
                minCostPath.first = ddict[leftHalfPathToBeSolve].first + fdict[rightHalfPathToBeSolve].first;
                minCostPath.second.first.clear();
                minCostPath.second.second.clear();
                minCostPath.second.first.insert(minCostPath.second.first.end(),
                        ddict[leftHalfPathToBeSolve].second.first.begin(),
                        ddict[leftHalfPathToBeSolve].second.first.end());
                minCostPath.second.first.insert(minCostPath.second.first.end(),
                        fdict[rightHalfPathToBeSolve].second.first.begin(),
                        fdict[rightHalfPathToBeSolve].second.first.end());
                minCostPath.second.second.insert(
                        minCostPath.second.second.end(),
                        ddict[leftHalfPathToBeSolve].second.second.begin(),
                        ddict[leftHalfPathToBeSolve].second.second.end());
                minCostPath.second.second.insert(
                        minCostPath.second.second.end(),
                        fdict[rightHalfPathToBeSolve].second.second.begin(),
                        fdict[rightHalfPathToBeSolve].second.second.end());
            }

        }

        fdict[key] = minCostPath;
    }
}

ActionConditions Planner::findActions(Actions actions, Conditions preConditions){
  ActionConditions result;
  for(auto& a: actions){
    Conditions postA = a->getPreConditions();
    if(satisfies(postA, preConditions)){
      
      Conditions yetToSatisfy;
    
      std::set_difference(preConditions.begin(),preConditions.end(),
			  postA.begin(), postA.end(),
			  std::inserter(yetToSatisfy, yetToSatisfy.begin())
			  );
      Conditions combined;
      Conditions preA = a->getPostConditions();

      std::set_union(preA.begin(), preA.end(),
		     yetToSatisfy.begin(), yetToSatisfy.end(),
		     std::inserter(combined, combined.begin()));
      bool c = false;
      for(auto& m : mutexes)
	if(satisfies(combined, m)){
	  c=true;break;
	}
      if(!c)
	result.insert({combined,a});
    }      
    
  }
  return result;
}

// Candidate function for interventions
static void onCubeTouch(void* ctxt, unsigned cid) {
    cond.next_condition();
    LOG("Condition %i\n", cond.get_condition_number());
    for(CubeID cid : CubeSet::connected()) {
        vbuf[cid].attach(cid);
        activateCube(cid);
    }
}

// When pressed, move to the next condition
void onTouch(void* ctxt, unsigned id) {
    CubeID cube(id);
    // On touchout (similar to mouseout)
    if (cube.isTouching() == 0) {
        cond.next_condition();
            LOG("Condition %i\n", cond.get_condition_number());
        for(CubeID cid : CubeSet::connected()) {
            vbuf[cid].attach(cid);
            activateCube(cid);
        }
    }
}

    void commit()
    {
        for ( Condition & condition : conditions )
        {
            std::for_each( condition.macros.begin(), condition.macros.end(), macroUsedCallback_ );
        }
        conditions.clear();

        std::for_each( macros.begin(), macros.end(), macroUsedCallback_ );
        macros.clear();
    }

			void Clear()
			{
				with_limit = false;
				limit_offset = 0;
				limit_count = -1;
				with_desc_asc = false;
				is_desc = false;
				with_alpha = false;
				aggregate = AGGREGATE_EMPTY;
				conds.clear();
				names.clear();
				orderby = Slice();
			}

static bool hideSideBar(CubeID cid, Side s) {
    // If cid is showing a bar on side s, hide it and check if the
    // blicket detector should turn off.
    ASSERT(activeCubes.test(cid));
    if (!vbuf[cid].sprites[s].isHidden()) {
        vbuf[cid].sprites[s].hide();
        if (barSpriteCount(cid) == 0 && cid == 0) {
            vbuf[cid].bg0.image(vec(0,0), Backgrounds, 0);
        }
        else {
            vbuf[cid].bg0.image(vec(0,0), cond.get_condition(), cid - 1);
        }
        return true;
    } else {
        return false;
    }
}

static bool showSideBar(CubeID cid, Side s) {
    // If cid is not showing a bar on side s, show it and check if the
    // blicket detector shold go off.
    ASSERT(activeCubes.test(cid));
    if (vbuf[cid].sprites[s].isHidden()) {
        vbuf[cid].sprites[s].setImage(Bars[s]);
        vbuf[cid].sprites[s].move(getRestPosition(s));
        if (barSpriteCount(cid) == 1 && cid == 0) {
            vbuf[cid].bg0.image(vec(0,0), Backgrounds, 1);
        }
        else {
            vbuf[cid].bg0.image(vec(0,0), cond.get_condition(), cid - 1);
        }
        return true;
    } else {
        return false;
    }
}

static void activateCube(CubeID cid) {
    // Mark cube as active and render its canvas
    //
    activeCubes.mark(cid);
    vbuf[cid].initMode(BG0_SPR_BG1);
    if (cid == 0) {
        vbuf[cid].bg0.image(vec(0,0), Backgrounds, 0);
    } else {
        vbuf[cid].bg0.image(vec(0,0), cond.get_condition(), cid - 1);
    }
    auto neighbors = vbuf[cid].physicalNeighbors();
    for(int side=0; side<4; ++side) {
        if (neighbors.hasNeighborAt(Side(side))) {
            showSideBar(cid, Side(side));
        } else {
            hideSideBar(cid, Side(side));
        }
    }
}