数据结构&算法-回溯算法& 贪心算法

回溯算法

概念

（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

运行结果

代码

using System;
using System.Collections.Generic;

namespace BacktrackingAlgor
{
    class Program
    {
        static void Main(string[] args)
        {

            BacktrackingAlgo algo = new BacktrackingAlgo(8);
            algo.OPt(0, 0, false);
            Console.ReadKey();
        }

    }
    class BacktrackingAlgo
    {
        int degr;
        int[,] map;
        List<PawnPos> pawnPosList;
        /// <summary>
        /// 已收集到的数量
        /// </summary>
        int collectNum = 0;
        struct PawnPos
        {
            public int x;
            public int y;

        }
        public BacktrackingAlgo(int degr)
        {
            this.degr = degr;
            map = new int[degr, degr];
            pawnPosList = new List<PawnPos>();
        }

        bool UnitJudge(PawnPos uPos)
        {
            if (uPos.x >= degr || uPos.y >= degr)
            {
                return false;
            }

            for (int i = 0; i < collectNum; i++)
            {

                if (pawnPosList[i].x == uPos.x || pawnPosList[i].y == uPos.y || Math.Abs(pawnPosList[i].x - uPos.x) == Math.Abs(pawnPosList[i].y - uPos.y))
                {
                    return false;
                }
            }

            return true;
        }

        public void OPt(int collectx, int collecty, bool isBack)
        {
            if (collectNum >= degr)
            {
                Console.WriteLine("满了");
                for (int i = 0; i < pawnPosList.Count; i++)
                {
                    Console.WriteLine(pawnPosList[i].x+"-"+ pawnPosList[i].y);
                }
                return;
            }
            else if (collectNum < 0)
            {
                Console.WriteLine("失败了");
                return;
            }
            PawnPos temp = new PawnPos();
            temp.x = collectx;
            if (isBack)
            {
                temp.y = pawnPosList[collectx].y + 1;
                CellOpt(temp);

            }
            else
            {

                temp.y = collecty;
                CellOpt(temp);


            }

        }

        void CellOpt(PawnPos pos)
        {

            if (UnitJudge(pos))//符合要求
            {
                collectNum++;
                if (pos.x >= pawnPosList.Count)
                {
                    pawnPosList.Add(pos);
                }
                else
                {
                    pawnPosList[pos.x] = pos;
                }

                OPt(collectNum, 0, false);
            }
            else
            {
                pos.y++;
                if (pos.y < degr)
                {
                    OPt(collectNum, pos.y, false);
                }
                else
                {
                    //  pawnPosList.Remove(pawnPosList[collectNum]);
                    collectNum--;
                    OPt(collectNum, 0, true);
                }
            }
        }
    }


}

参考

小白带你学—回溯算法（Back Tracking)

贪心算法

概念

所谓贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，它所做出的仅仅是在某种意义上的局部最优解。

内容

最短路径算法（一） Dijkstra算法（贪心算法）
请参考我之前的文章:
数据结构&算法-图最短路径
大体思路：先从0点出发，其它所有结点中，到0点权值最小的节点为A，权值为AQ，然后这个结点A所能辐射的范围的节点X，这些X结点与0点的权值为XQ，与 AQ + AXQ的权值比较，如果后者比较小，则把XQ的权值更新，然后再找这些XQ中的最小权值。直到最后。