学习心得：数据结构与算法之回朔（一个“框架”）

一、回溯算法简单说就是“一直向前走，碰壁就会头”。一个经典的例子是走迷宫，一直向前走，碰壁就回头。下面就看看这个“框架”（vc6.0下编译）：

/**//////////////////////////
// Application.h

#ifndef APPLICATION_H
#define APPLICATION_H

#include "iostream.h"
#include "Position.h"

class Application
...{
protected:
    friend ostream& operator << (ostream& stream, Application& app);

public:
    Position generateInitialState();
    bool valid (const Position &pos);
    bool done (const Position &pos);
    void record (const Position &pos);
    void undo (const Position &pos);

    class Iterator
    ...{
    protected:
        void* fieldPtr;

    public:
        Iterator ();
        Iterator (const Position& pos);
        Position operator ++ (int);
        bool atEnd (); 
    };
};


#endif 

/**////////////////////////////////////////
//  BACKTRACK_H
#ifndef BACKTRACK_H
#define BACKTRACK_H

#include "Application.h"
#include "Position.h"

class BackTrack
...{
public:
    BackTrack (Application &app);
    bool tryToSolve (Position& pos);
protected:
    Application app;
};
    
#endif

 

/**///////////////////////
//BrackTrack.cpp
#include "BackTrack.h"

BackTrack::BackTrack (Application &app)
...{
    this->app = app;
}

bool BackTrack::tryToSolve (Position &pos)
...{
    bool success = false;

    Application::Iterator itr(pos);
    while (!success && !itr.atEnd())
    ...{
        pos = itr++;
        if (app.valid(pos))
        ...{
            app.record(pos);
            if (app.done(pos))
                success = true;
            else
            ...{
                success = tryToSolve(pos);
                if (!success)
                    app.undo(pos);
            }
        }
    }
    return success;
}

 

/**//////////////////////////////
//main,cpp
#include "iostream.h"
#include "string.h"
#include "BackTrack.h"
#include "Application.h"
#include "Position.h"

int main()
...{
    Application app;
    BackTrack b(app);

    Position pStart = app.generateInitialState();
    //cout<<app;
    
    if (!app.valid(pStart))
        cout << "there is no solution:" << endl;
    else
    ...{
        app.record (pStart);
        if (app.done (pStart) || b.tryToSolve(pStart))
            cout << "success" << endl;
        else
        ...{
            app.undo(pStart);
            cout << "there is no solution" << endl;
        }
    }
    return 0;
}

 

二、下面就以迷宫为例子用这个“框架”

 

/**//////////////////////////////////////////
// POSITION_H

#ifndef POSITION_H
#define POSITION_H

class Position
...{
protected:
    int nRow;
    int nColumn;

public:
    Position();
    Position(int nRow, int nColumn);
    void SetPosition(int nRow, int nColumn);
    int GetRow() const;
    int GetColumn() const;
};

#endif

/**///////////////////////////////////
//  Position.cpp
#include "Position.h"

Position::Position()
...{
    nRow = 0;
    nColumn = 0;
}

Position::Position(int nRow, int nColumn)
...{
    this->nRow = nRow;
    this->nColumn = nColumn;
}

void Position::SetPosition(int nRow, int nColumn)
...{
    this->nRow = nRow;
    this->nColumn = nColumn;
}

int Position::GetRow() const
...{
    return nRow;
}

int Position::GetColumn() const
...{
    return nColumn;
}

/**////////////////////////////////////
//Application.cpp

#include "iostream.h"
#include "Application.h"
#include "Position.h"

const short WALL = 0;
const short CORRIDOR = 1;
const short PATH = 9;
const short TRIED = 2;
const short ROWS = 8;
const short COLUMNS = 13;

short grid[ROWS][COLUMNS] = 
...{
    ...{1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1},
    ...{1 , 0 , 1 , 1 , 1 , 0 , 1 , 1 , 1 , 1 , 1 , 0 , 1},
    ...{1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 1 , 0 , 1},
    ...{1 , 0 , 1 , 0 , 0 , 1 , 1 , 0 , 1 , 0 , 1 , 1 , 1},
    ...{1 , 1 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1},
    ...{1 , 0 , 1 , 0 , 0 , 1 , 0 , 1 , 0 , 0 , 0 , 0 , 1},
    ...{1 , 0 , 0 , 0 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 1},
    ...{1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1},
};

Position posStart;
Position posFinish;



Position Application::generateInitialState()
...{
    int nRow;
    int nColumn;

    cout << "Please enter the start row and start column:";
    cin >> nRow >> nColumn;
    posStart.SetPosition(nRow, nColumn);
    cout << endl;
    cout << "Please enter the finish row and finish column:";
    cin >> nRow >> nColumn;
    cout << endl;
    posFinish.SetPosition (nRow, nColumn);
    return posStart;
}

bool Application::valid(const Position& pos) 
...{
    if (pos.GetRow() >= 0 && pos.GetRow() < ROWS &&
        pos.GetColumn() >= 0 && pos.GetColumn() < COLUMNS &&
        grid[pos.GetRow()][pos.GetColumn()] == CORRIDOR)
    ...{
        return true;
    }
    return false;
}

void Application::record(const Position &pos)
...{
    grid[pos.GetRow()][pos.GetColumn()] = PATH;   //标识该点为已经在路径中
}

bool Application::done(const Position &pos)
...{
    return posFinish.GetRow() == pos.GetRow() &&
        posFinish.GetColumn() == pos.GetColumn();
}

void Application::undo(const Position &pos)
...{
    grid[pos.GetRow()][pos.GetColumn()] = TRIED;  //此路不通
}

ostream& operator << (ostream& stream, Application* app)
...{
    for (int nRow = 0 ; nRow < ROWS ; nRow++)
    ...{
        for (int nColumn = 0 ; nColumn < COLUMNS ; nColumn)
            cout << grid[nRow][nColumn] << " ";
        cout << endl;
    }
    return stream;
}


// Iterztor
typedef struct _tagItrFields
...{
    int nRow;
    int nColumn;
    int nDirection;
}ITRFIELDS, *LPITRFIELDS;

Application::Iterator::Iterator(const Position &pos)
...{
    LPITRFIELDS itrPtr = new ITRFIELDS;
    itrPtr->nColumn = pos.GetColumn();
    itrPtr->nRow = pos.GetRow();
    itrPtr->nDirection = 0;
    fieldPtr = itrPtr;
}

Position Application::Iterator::operator ++ (int)
...{
    LPITRFIELDS itrPtr = (LPITRFIELDS)fieldPtr;
    int nRow = itrPtr->nRow;
    int nColumn = itrPtr->nColumn;

    switch(itrPtr->nDirection++)
    ...{
    case '0':
        nRow--;
        break;
    case '1':
        nColumn++;
        break;
    case '2':
        nRow++;
        break;
    case '3':
        nColumn--;
        break;
    default:
        break;
    }
    Position next(nRow, nColumn);
    return next;
}

bool Application::Iterator::atEnd()
...{
    return ((LPITRFIELDS)fieldPtr)->nDirection >= 3;
}