SlnTable MarkingBoolVertex(const BoolVertexEdge_list &main_table, const std::vector< std::set< BoolVertex > > &boolvertexcond) {
Graph< std::set< BoolVertex >, AreStrongComponentsVertexConnected, std::vector< std::set< BoolVertex > >::const_iterator,
BoolVertexEdge_list::const_iterator > g2(boolvertexcond.begin(), boolvertexcond.end(), main_table.begin(), main_table.end());
cVector temp = g2.topological_sort();
std::deque< vSet > top_sort(temp.begin(), temp.end());
SlnTable solution;
cSet is_marked;
while (!top_sort.empty()) {
if (is_marked.find(*top_sort.rbegin()) == is_marked.end()) {
solution[*top_sort.rbegin()] = 0;
is_marked.insert(*top_sort.rbegin());
}
if (is_marked.find(*(top_sort.rend() - 1)) == is_marked.end()) {
solution[*(top_sort.rend() - 1)] = 1;
is_marked.insert(*(top_sort.rend() - 1));
}
std::for_each(top_sort.rbegin(), top_sort.rend(), [&] (const vSet &v) {
if (StrongComponentsAreOpposite(std::make_pair(v, *top_sort.rbegin()))) {
solution[v] = 1;
is_marked.insert(v);
}
if (StrongComponentsAreOpposite(std::make_pair(v, *(top_sort.rend() - 1)))) {
solution[v] = 0;
is_marked.insert(v);
}
});
top_sort.pop_back();
top_sort.pop_front();
}
return solution;
}
bool Doc2Vec::obj_knn_objs(const char * search, real * src,
bool search_is_word, bool target_is_word,
knn_item_t * knns, int k)
{
long long a = -1, b, c, target_size;
real * search_vectors, * target, * target_vectors;
Vocabulary * search_vocab, * target_vocab;
search_vocab = search_is_word ? m_word_vocab : m_doc_vocab;
search_vectors = search_is_word ? m_nn->m_syn0norm : m_nn->m_dsyn0norm;
target_vectors = target_is_word ? m_nn->m_syn0norm : m_nn->m_dsyn0norm;
target_size = target_is_word ? m_nn->m_vocab_size : m_nn->m_corpus_size;
target_vocab = target_is_word ? m_word_vocab : m_doc_vocab;
if(!src) {
a = search_vocab->searchVocab(search);
if(a < 0) return false;
src = &(search_vectors[a * m_nn->m_dim]);
}
for(b = 0, c = 0; b < target_size; b++)
{
if(search_is_word == target_is_word && a == b) continue;
target = &(target_vectors[b * m_nn->m_dim]);
if(c < k){
knns[c].similarity = similarity(src, target);
knns[c].idx = b;
c++;
if(c == k) top_init(knns, k);
}
else top_collect(knns, k, b, similarity(src, target));
}
top_sort(knns, k);
for(b = 0; b < k; b++) strcpy(knns[b].word, target_vocab->m_vocab[knns[b].idx].word);
return true;
}
int main()
{
FILE *file;
/* graph[i][j] == 1 iff there is a sequence "ij" in the input */
int graph[10][10];
int sort[10];
/* Nodes that occur in input. We want the shortest sequence so we assume
* that no nodes are in the graph to start with, but we do need to keep
* track of nodes with no outgoing edges */
int nodes[10];
char curr[3];
int i;
if ((file = fopen("./keylog-short.txt", "r")) == NULL)
{
printf("fopen failed\n");
return -1;
}
/* Initialize data structures */
memset(graph, 0, 10*10*sizeof(int));
memset(nodes, 0, 10*sizeof(int));
while (fscanf(file, "%s", curr) != EOF)
{
graph[curr[0] - '0'][curr[1] - '0'] = 1;
graph[curr[1] - '0'][curr[2] - '0'] = 1;
nodes[curr[0] - '0'] = 1;
nodes[curr[1] - '0'] = 1;
nodes[curr[2] - '0'] = 1;
}
top_sort(graph, sort);
for (i = 0; i < 10 && sort[i] > 0; i++)
{
printf("%d", sort[i]);
// Unset this so we can print the remaining ones in the next
// step
nodes[sort[i]] = 0;
}
/* Add any numbers which have no successors */
for (i = 0; i < 10; i++)
{
if (nodes[i])
{
printf("%d", i);
}
}
printf("\n");
fclose(file);
return 0;
}
/*
* Returns the longest path in the given graph. The given graph must be a DAG.
* The reverse of the graph must also be passed to this function
*/
ll_node* longest_path_dag(graph* g,graph* flipped,int* len_dest) {
vertex* ord = top_sort(g,flipped);
int weights[g->numV];
int parents[g->numV];
for(int i=g->numV-1;i>=0;i--) {
weights[i]=0;
parents[i]=-1;
}
for(int i=0;i<g->numV;i++)
DBG(("%i %i\t",parents[i],weights[i]));
DBG(("\n"));
for(int i=0;i<g->numV;i++) {
vertex v = ord[i];
for(int j = v.numE-1;j>=0;j--) {
arc d = v.edges[j];
if(weights[d.dest] <= weights[v.label] + d.len) {
weights[d.dest] = weights[v.label] + d.len;
parents[d.dest] = v.label;
}
}
for(int i=0;i<g->numV;i++)
DBG(("%i %i\t",parents[i],weights[i]));
DBG(("\n"));
}
int max = 0, maxI = -1;
for(int i=g->numV-1;i>=0;i--)
if(weights[i] > max) {
max = weights[i];
maxI = i;
}
*len_dest = max;
ll_node* path = NULL;
int cur = maxI;
while(cur != -1) {
DBG(("%i\n",cur));
ll_node* new_path = malloc(sizeof(struct ll_node));
new_path->data = (void*)(long)cur;
new_path->next = path;
path = new_path;
cur = parents[cur];
}
free(ord);
return path;
}
int glp_top_sort(glp_graph *G, int v_num)
{ glp_vertex *v;
int i, cnt, *num;
if (v_num >= 0 && v_num > G->v_size - (int)sizeof(int))
xerror("glp_top_sort: v_num = %d; invalid offset\n", v_num);
if (G->nv == 0)
{ cnt = 0;
goto done;
}
num = xcalloc(1+G->nv, sizeof(int));
cnt = top_sort(G, num);
if (v_num >= 0)
{ for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
memcpy((char *)v->data + v_num, &num[i], sizeof(int));
}
}
xfree(num);
done: return cnt;
}
static void
assignTrackNo (Dt_t* chans)
{
Dt_t* lp;
Dtlink_t* l1;
Dtlink_t* l2;
channel* cp;
int k;
for (l1 = dtflatten (chans); l1; l1 = dtlink(chans,l1)) {
lp = ((chanItem*)l1)->chans;
for (l2 = dtflatten (lp); l2; l2 = dtlink(lp,l2)) {
cp = (channel*)l2;
if (cp->cnt) {
#ifdef DEBUG
if (odb_flags & ODB_CHANG) dumpChanG (cp, ((chanItem*)l1)->v);
#endif
top_sort (cp->G);
for (k=0;k<cp->cnt;k++)
cp->seg_list[k]->track_no = cp->G->vertices[k].topsort_order+1;
}
}
}
}
void test_top_sort(Graph *g) {
int s;
int i, j;
int len = g->vertexNum;
int *result = (int *)malloc(len * sizeof(int));
if(result == NULL) {
printf("malloc failed\n");
return;
}
memset(result, 0, len * sizeof(int));
printf("Input a suggest first node: ");
scanf("%d", &s);
top_sort(g, s, result);
for(i=0;i<len;i++) {
for(j=0;j<len;j++) {
if(result[j] == i)
printf("%d", j);
}
if(i < len -1)
printf("->");
}
printf("\n");
free(result);
}
int main(int argc, char** argv)
{
int m;
int i;
char s[4];
while(scanf("%d%d", &n, &m) == 2)
{
t = n;
memset(G, 0, sizeof(G));
for(i = 0; i < m; i++)
{
scanf("%s", s);
G[s[0]-'a'][s[2]-'a'] = 1;
}
if(top_sort())
{
for(i = 0; i < n; i++)
printf("%c ", 'a'+ans[i]);
printf("\n");
}
else printf("-1\n");
}
return 0;
}
