flagman — Sun, 27 Feb 2011 09:09:00 GMT

�q�道千分题，其实是挺有意思的一题：
提供了点�Q�这里是junction�Q�和点之间的距离�Q�或代�h�Q�；
要求以最短的距离�Q�或最��代��P��遍历所有的点，同时每个点可以多�ơ访问；

初看之下�Q�给人的感觉是图论相关的问题�Q�比如旅行者问题、欧拉环�怹��c�R�?/p>

在思考这个问题的时候，忽然间联惛_��了图��Z��的最��生成树�Q�虽然�ƈ不是真正要去得出最��生成树�Q?/p>

但是按照最��生成树所提供的思�\--�q�点很重�?-那就是图和树之间有着相当密切的关�p�：即��最��生

成树�q�不能直接解册��个问题，但是它们之间存在的这层关�pȝ��提供了解决问题的一个有益的��试�?/p>

向；

于是�Q�思考进了一步，问题�?#8220;�?#8221;��化成�?#8220;�?#8221;--如何把当前这个问题采用树的结构和�Ҏ��表达�?/p>

来：树的根节点，很自然地惛_��了由问题中旅行的起始节点来表达；然后�Q�随着节点的不断加入，树就

自然地生成，此处的关键在于如何生成，或者说节点加入的规则，以及每个节点��Z��适应�q�个规则�Q�所

必须持有的相兛_��性信息：最直接的，父子节点之间的关�p�需要维护，从父节点到子节点的距��（或代

��P��必须要保留，其次�Q�考虑到如果每个节炚w��l�护相关的距��（代�h�Q�信息，那么从当前节点到根节

点的代�h也就可以由此递推得出�Q�进一步，我们所要求出的最短�\径（或最��代��P��不就可以从上�q�这

些节点中�l�护的距��M��息中得出吗？�q�是非常关键的一步，它把当前我们构徏的数据结构和问题的要�?/p>

之间建立起了相当直接的联�p�R��这说明我们目前思考的方向是有价值的而且极有可能��着�q�个方向前行

�Q�可以得出相当不错的�l�果�?/p>

昄��Q�既然要求最短�\径（最��代��P��Q�那么我们目前构建出的这颗Junction树（因�ؓ其上的节点在�?/p>

中的物理含义是代表Junction�Q�那�q�里我们��姑且称其�ؓJunction Tree�Q�，树上的每个节点也应当保留

在其之下的子树的最短�\径（最��代��P��Q�这��q��当于把每个节炚w��作�ؓ根节点，然后求出各条子�\�?/p>

的代��P��q�比较得出最短�\径（最��代��P��Q�以及在�q�条最短�\径上的直接子节点�Q?/p>

每加入一个子节点�Q�就要对上述已构建出的这些数据结构中的信息进行维护，以调整每个节点当前的最

短�\径代价和相应�q�条路径上的直接子节点；当所有原“�?#8221;中的“�?#8221;信息�Q�也��是

(fromJunction,toJuction,ductLength)所代表的（起始点，�l�止点，长度代�h�Q�，都按照上�q�方案加�?/p>

Juction Tree之后�Q�我们可以知道从最初的起始节点�Q�也��是Junction Tree的根节点�Q�到最�l�节点的�Q?/p>

Junction Tree上的某条路径上的叶子节点�Q�的最短（最��代��P��路径了�?/p>

对于Juction Tree�q�个ADT抽象数据�l�构的具体实玎ͼ�考虑��C��先队列中二叉堆的�l�典实现往往使用数组

�Q�同时也��Z��W�合TC SRM一贯的��h��快的�E�序设计风格�Q�我们这里同时��用几个数�l�来�l�护前述构徏

出的数据�l�构�?/p>

//////////////////////////////////////////////////////////////////////////////////////////

#include
#include
#include
using namespace std;

const int NIL = -1;
const int MAX = 50;

int Cost[MAX];
int ParentNode[MAX];
int MaxSubNode[MAX];
int MaxSubCost[MAX];

class PowerOutage
{
public:
int estimateTimeOut(vector fromJunction, vector toJunction, vector

ductLength)
{
  if (!CheckParameter(fromJunction, toJunction, ductLength)) return NIL;

  Ini();
  int count = fromJunction.size();
  for (int i = 0; i < count; i++)
  {
   AddNode(fromJunction[i], toJunction[i], ductLength[i]);
  }

  return CalculateMinCost(fromJunction, toJunction, ductLength);
}
private:
void Ini()
{
  memset(Cost, NIL, sizeof(int) * MAX);
  memset(ParentNode, NIL, sizeof(int) * MAX);
  memset(MaxSubNode, NIL, sizeof(int) * MAX);
  memset(MaxSubCost, 0, sizeof(int) * MAX);
}

bool CheckParameter(const vector& fromJunction, const vector& toJunction,

const vector& ductLength)
{
if (fromJunction.size() != toJunction.size() || toJunction.size() !=

ductLength.size())
   return false;
  return true;
}

void AddNode(int parent, int child, int cost)
{
  if (parent < 0 || child < 0 || cost < 0) return;

  Cost[child] = cost;
  ParentNode[child] = parent;

  int curParent = parent, curChild = child;
  bool adjustParentCost = true;
  while (adjustParentCost && curParent != NIL)
  {
   int candidateParentMaxSubCost = Cost[curChild] + MaxSubCost

[curChild];
   if (MaxSubCost[curParent] < candidateParentMaxSubCost)
   {
    MaxSubCost[curParent] = candidateParentMaxSubCost;
    MaxSubNode[curParent] = curChild;

    curChild = curParent;
    curParent = ParentNode[curParent];
   }
   else
   {
    adjustParentCost = false;
   }
  }
}

int CalculateMinCost(const vector& fromJunction, const vector&

toJunction, const vector& ductLength)
{
  int len = fromJunction.size();
  int minCost = 0;

  set minCostPath;
  minCostPath.insert(0);
  int curNode = MaxSubNode[0];
  while(curNode != NIL)
  {
   printf("%d;",curNode); // print the min cost path

   minCostPath.insert(curNode);
   curNode = MaxSubNode[curNode];
  }

  for (int i = 0; i < len; i++)
  {
   if (minCostPath.find(toJunction[i]) == minCostPath.end())
    minCost += 2 * ductLength[i];
   else
    minCost += ductLength[i];
  }

  return minCost;
}
};

flagman 2011-02-27 17:09 发表评论

99精品国产在热久久 ,久久伊人影视,狠狠色丁香久久婷婷综合五月