Algorithm 从n个列表中选择n个唯一元素

我一直在考虑一个编程问题。如果有n个列表，我们希望输出n个不同的元素（每个元素来自不同的列表）。我怀疑这可以通过某种回溯算法来解决，但我不知道如何正确地实现它。

尽管您可以按照评论中的建议通过回溯来解决，但更有效的解决方案是使用最大流算法。
将其建模为图形。源、接收器、每个不同元素的节点和每个列表的节点。 您将源连接到每个不同的元素。每个元素连接到它所在的每个列表。以及连接到接收器节点的列表。每个边的容量为1。
最大流是可以从不同列表中选择的不同元素的最大数量

---

虽然您可以按照评论中的建议使用回溯解决此问题，但更有效的解决方案是使用最大流算法。
将其建模为图形。源、接收器、每个不同元素的节点和每个列表的节点。 您将源连接到每个不同的元素。每个元素连接到它所在的每个列表。以及连接到接收器节点的列表。每个边的容量为1。
最大流是可以从不同列表中选择的不同元素的最大数量

---

我不确定这是否没有bug，是否解决了问题；我希望这次我正确地理解了这个问题：）

//测试
int[]arr=新int[]{
新的int[]{1,1,1,1,6}，
新的int[]{1,1,1,1,5}，
新的int[]{1,1,1,4,9}，
新的int[]{1,1,3,8,1}，
新的int[]{1,2,7,1,1}，
新的int[]{1,1,1,1,1}；
int[]res=getItems（arr）.ToArray（）//6,5,4,3,2,1
私有静态IEnumerable getItems（T[][]数组）
{
int N=array.GetLength（0）；
项目[]项目=新项目[N]；
HashSet hs=新的HashSet（）；
对于（int i=0；i=array[i].Length）；
hs.Clear（）；
对于（int j=0；j

我不确定这是否没有bug，是否解决了问题；我希望这次我正确地理解了这个问题：）

//测试
int[]arr=新int[]{
新的int[]{1,1,1,1,6}，
新的int[]{1,1,1,1,5}，
新的int[]{1,1,1,4,9}，
新的int[]{1,1,3,8,1}，
新的int[]{1,2,7,1,1}，
新的int[]{1,1,1,1,1}；
int[]res=getItems（arr）.ToArray（）//6,5,4,3,2,1
私有静态IEnumerable getItems（T[][]数组）
{
int N=array.GetLength（0）；
项目[]项目=新项目[N]；
HashSet hs=新的HashSet（）；
对于（int i=0；i=array[i].Length）；
hs.Clear（）；
对于（int j=0；j

设置一组数字，您可以从每个列表中选择。从第一个列表中选择一个数字，并将其从每个池中删除。如果某个池曾经被排空，请返回到上一个状态并尝试拾取下一个元素。如果你需要更多的信息，谷歌的实现就是其中的全部。更清楚的是：你想从每个列表中选择一个元素，比如

            //test
            int[][] arr = new int[][] {
            new int[] { 1, 1, 1, 1, 6 },
            new int[] { 1, 1, 1, 1, 5 },
            new int[] { 1, 1, 1, 4, 9 },
            new int[] { 1, 1, 3, 8, 1 },
            new int[] { 1, 2, 7, 1, 1 },
            new int[] { 1, 1, 1, 1, 1 } };

            int[] res = getItems(arr).ToArray(); //6,5,4,3,2,1

        private static IEnumerable<T> getItems<T>(T[][] array)
        {
            int N = array.GetLength(0);
            item<T>[] items = new item<T>[N];

            HashSet<T> hs = new HashSet<T>();
            for (int i = 0; i < N; i++)
            {
                bool ok = false;
                T[] arr = array[i];
                for (int j = items[i].Index; j < arr.Length; j++)
                {
                    T val = arr[j];
                    if (hs.Add(val))
                    {
                        items[i] = new item<T>() { Val = val, Index = j };
                        ok = true;
                        break;
                    }
                }
                if (!ok)
                {
                    item<T> item;
                    do
                    {
                        if (i == 0) throw new Exception("no solution");
                        items[i] = new item<T>();
                        item = items[--i];
                        item.Index++;
                        items[i] = item;
                    }
                    while (item.Index >= array[i].Length);
                    hs.Clear();
                    for (int j = 0; j < i; j++)
                        hs.Add(array[j][items[j].Index]);
                    i--;
                }
            }
            return hs;
        }
        private struct item<T>
        {
            public T Val;
            public int Index;

            public override string ToString()
            {
                return string.Format("Val:{0} Index:{1}", Val, Index);
            }
        }