查找许多事件之间的顺序

Question

目前正在解决一个谜题并寻找按订购事件排序的一些提示。我想知道我应该遵循的程序究竟是什么。考虑一下这个

我输入一个数字，然后输入n个输入     每个输入都有两个事件，其中event1 event2和event1发生在event2之前。

考虑输入

6
Eatfood Cuthair
Eatfood BrushTeeth
School  EatFood
School  DoHair
DoHair   Meeting
Meeting Brushteeth

输出

school -> dohair-> eatfood -> meeting -> cuthair -> brushteeth

按此顺序。因为如果我们写下所有东西，学校确实是第一件事，然后dohair是第二。如果存在多个可能的排序，则只输出一个。您可以假设所有事件都以某种方式连接，并且不存在循环依赖关系。

我正在考虑做的是制作两个数组，一个包含所有eventOne's和所有eventTwo's。我不确定从哪里开始。我想在javascript中这样做。谢谢！建议使用任何提示或算法

另一个输入

6
vote_140_prof announce_140_prof
vote_140_prof first_day_of_classes
dev_shed_algo vote_140_prof
dev_shed_algo do_hair
do_hair big_meeting
big_meeting first_day_of_classes

输出

dev_shed_algo do_hair vote_140_prof big_meeting announce_140_prof first_day_of_classes

我在我的计算机上找到了解决方案文件，它在python中我不知道，但希望这会帮助其他人理解这个问题

from collections import defaultdict

def toposort(graph, roots):
    res = [i for i in roots]
    queue = [i for i in roots]
    while queue:
        for i in graph[queue.pop(0)]:
            if i not in res:
                res.append(i)
                queue.append(i)
    return res

graph = defaultdict(set)
a_set = set()
b_set = set()

for i in range(int(input())):
    a, b = input().split()
    a_set.add(a)
    b_set.add(b)
    graph[a].add(b)

print(" ".join(i for i in toposort(graph, a_set - b_set)))

我的尝试

var words =
    'vote_140_prof announce_140_prof vote_140_prof first_day_of_classes devshed_algo vote_140_prof dev_shed_algo do_hair do_hair big_meeting big_meeting first_day_of_classes';

var events = words;

events = events.split(/\s+/);
console.log(events);

var obj = {};
for (var i = 0 ; i < events.length ; i++)
    {
        var name = events[i];
        if(obj[name] === undefined )
            {
                obj[name] = [];
            }

        obj[name].push(events[i%2 === 1 ? i-1 : i+1]);
    }
console.log(obj);

格式化

function sequenceEvents(pairs){
        var edges = pairs.reduce(function(edges,pair){
            edges.set(pair[0],[]).set(pair[1],[]);
            new Map();
        });

        pairs.forEach(function(edges,pair){

            edges.set(pair[0],[]).set(pair[1],[]);

        });

        var result = [];

        while(edges.size){
            var children = new Set([].concat.apply([],[...edges.value()]));
            var roots = [...edges.keys()].filter(function(event){
                !children.has(event);
            });

            if(!roots.length) throw "Cycle detected";
        roots.forEach(function(root){
           result.push(root);
           edges.delete(root);

        });

        }

        return result;

    }

Answer 1

好。这是我对这个问题的看法。

var makePair = function(i0, i1) {
    return {start: i0, end: i1};
};

var mp = makePair;

var makeBefores = function(pairs) {
    var befores = {};
  pairs.forEach(function(pair) {
    if (befores[pair.end] == null) {
        befores[pair.end] = [pair.start];
    } else {
        befores[pair.end].push(pair.start);
    }
    if (befores[pair.start] == null) {
        befores[pair.start] = [];
    }
  });
  for (var key in befores) {
    console.log("after " + key + "there is:");
    for (var i = 0; i < befores[key].length; i++) {
        console.log(befores[key][i]);
    }
  }

  return befores;
};

var shouldGoBefore = function(item, before) {
    for (var i = 0; i < before.length; i++) {
    if (item == before[i]) {
        return true;
    }
  }
  return false;
};

var sortEvents = function(pairs) {
    if (pairs.length === 0) {
    return [];
  }
  if (pairs.length === 1) {
    return [pairs[0].start, pairs[0].end];
  }
  console.log(pairs);
  var befores = makeBefores(pairs);
  var sorted = [];
  for (var key in befores) {
    var added = false;
    for (var i = 0; i < sorted.length; i++) {
    console.log('checking if ' + sorted[i] + ' should go before ' + befores[key]);
        if (shouldGoBefore(sorted[i], befores[key])) {
            //console.log("splicing");
        sorted.splice(i, 0, key);
        added = true;
        break;
      }
    }
    if (!added) {
        sorted.push(key);
    }
  }
  return sorted.reverse();
}

var pairs = [mp('vote_140_prof','announce_140_prof'),mp('vote_140_prof','first_day_of_classes'),mp('dev_shed_algo','vote_140_prof'),mp('dev_shed_algo','do_hair'),mp('do_hair','big_meeting'),mp('big_meeting','first_day_of_classes'),mp('announce_140_prof','first_day_of_classes')];
console.log(sortEvents(pairs));

事情可能不起作用的一个原因是您的测试数据具有不一致的大小写。这次运行的结果是：

Array [ "School", "EatFood", "CutHair", "Meeting", "BrushTeeth", "DoHair" ]

我要在你的其他数据集上测试它，但我相信这会满足提示。我将在一分钟内写下它是如何运作的。

请注意，这不会执行任何文件IO或读取行。它将sortEvents的输入作为具有start和end属性的对象数组，我提供了一个辅助方法makePair来创建。

该解决方案的工作原理是建立一个字典，列出哪些元素先于其他元素。

如果你有如下输入：

a->b
c->a
c->b
b->d

字典会是这样的：

a->[c],
c->[],
b->[a,c],
d->[b]

然后我们使用一个数组作为一种链表，我们会看看是否需要插入一些东西。例如，如果我们要查看应插入a的位置且列表为c，那么我们会查看c的字典，看看c在其中，然后我们知道在a之前应该c，因此我们必须在a之后插入c

Answer 2

Python算法不正确。这个输入会失败：

3
A B
A C
C B

将输出：

A, B, C

...与最后一条规则相冲突。这是因为它错误地假定任何根事件的子节点都可以安全地添加到结果中，并且不依赖于其他事件。在上面的例子中，它将A标识为根，B和C标识为其子级。然后它将从该列表中弹出C，并将其添加到结果中，而不会看到C依赖于B，而B尚未在结果中。

正如其他人所说，您需要确保大小写是一致的。 Brushteeth和BrushTeeth被视为不同的事件。 EatFood和Eatfood也是如此。

我在这提供一个解决方案。我希望内联评论能够很好地解释发生的事情：

＆＃13;

＆＃13;

function sequenceEvents(pairs) {
    // Create a Map with a key for each(!) event, 
    // and add an empty array as value for each of them.
    var edges = pairs.reduce(
        // Set both the left and right event in the Map 
        //   (duplicates get overwritten)
        (edges, pair) => edges.set(pair[0], []).set(pair[1], []),
        new Map() // Start with an empty Map
    );
    // Then add the children (dependent events) to those arrays:
    pairs.forEach( pair => edges.get(pair[0]).push(pair[1]) );

    var result = [];
    // While there are still edges...
    while (edges.size) {
        // Get the end points of the edges into a Set
        var children = new Set( [].concat.apply([], [...edges.values()]) );
        // Identify the parents, which are not children, as roots
        var roots = [...edges.keys()].filter( event => !children.has(event) );
        // As we still have edges, we must find at least one root among them.
        if (!roots.length) throw "Cycle detected";
        roots.forEach(root => {
            // Add the new roots to the result, all events they depend on
            // are already in the result:
            result.push(root);
            // Delete the edges that start with these events, since the
            // dependency they express has been fulfilled:
            edges.delete(root);
        });
    }
    return result;
}


// I/O
var input = document.querySelector('#input');
var go = document.querySelector('#go');
var output = document.querySelector('#output');

go.onclick = function() {
    // Get lines from input, ignoring the initial number
    // ... then split those lines in pairs, resulting in
    // an array of pairs of events
    var pairs = input.value.trim().split(/\n/).slice(1)
                     .map(line => line.split(/\s+/));
    var sequence = sequenceEvents(pairs);
    output.textContent = sequence.join(', ');
}

＆＃13;

Input:<br>
<textarea id="input" rows=7>6
EatFood CutHair
EatFood BrushTeeth
School  EatFood
School  DoHair
DoHair   Meeting
Meeting BrushTeeth
</textarea>
<button id="go">Sequence Events</button>
<div id="output"></div>

＆＃13;

＆＃13;

＆＃13;

没有箭头功能，也没有apply

在评论中，您表示您希望首先使用不带箭头功能的代码：

function sequenceEvents(pairs) {
    // Create a Map with a key for each(!) event, 
    // and add an empty array as value for each of them.
    var edges = pairs.reduce(function (edges, pair) {
        // Set both the left and right event in the Map 
        //   (duplicates get overwritten)
        return edges.set(pair[0], []).set(pair[1], []);
    }, new Map() ); // Start with an empty Map
    // Then add the children (dependent events) to those arrays:
    pairs.forEach(function (pair) {
        edges.get(pair[0]).push(pair[1]);
    });

    var result = [];
    // While there are still edges...
    while (edges.size) {
        // Get the end points of the edges into a Set
        var children = new Set(
            [...edges.values()].reduce(function (children, value) {
                return children.concat(value);
            }, [] )
        );
        // Identify the parents, which are not children, as roots
        var roots = [...edges.keys()].filter(function (event) {
            return !children.has(event);
        });
        if (!roots.length) throw "Cycle detected";
        roots.forEach(function (root) {
            // Add the new roots to the result, all events they depend on
            // are already in the result:
            result.push(root);
            // Delete the edges that start with these events, since the
            // dependency they express has been fulfilled:
            edges.delete(root);
        });
    }
    return result;
}

Answer 3

将哈希映射从第一个事件开始并将其值设置为0，而不是每当遇到事件2时检查哈希中事件1的值，而不是为事件2设置较小的值。一旦按值完成排序哈希值

Bingo

line = input();
myMap = dict()
i=0
while i < line:
        event1 = raw_input()
        event2 = raw_input()
        if event1 in myMap :
                myMap[event2] = myMap[event1]+1
        elif event2 in myMap:
                myMap[event1] = myMap[event2]-1
        else :
                myMap[event1] = 0
                myMap[event2] = 1
        i=i+1
        print i
        print myMap

我不知道为什么有些人会被投票，但是他们正在工作，Atleast就你的两个样本

示例输入和输出

6
eatfood
cuthair
1
{'eatfood': 0, 'cuthair': 1}
eatfood
brushteeth
2
{'brushteeth': 1, 'eatfood': 0, 'cuthair': 1}
school
eatfood
3
{'brushteeth': 1, 'eatfood': 0, 'school': -1, 'cuthair': 1}
school
dohair
4
{'brushteeth': 1, 'eatfood': 0, 'school': -1, 'cuthair': 1, 'dohair': 0}
dohair
meeting
5
{'school': -1, 'brushteeth': 1, 'cuthair': 1, 'dohair': 0, 'eatfood': 0, 'meeting': 1}
meeting
brushteeth
6
{'school': -1, 'brushteeth': 2, 'cuthair': 1, 'dohair': 0, 'eatfood': 0, 'meeting': 1}

代码在python中，随意转换为javascript