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 发表评论

一个抽��L��问题

flagman — Fri, 03 Dec 2010 02:53:00 GMT

前些天在论坛上看��C��个看似简单，其实挺有意思的问题�Q?br>
�?0个连�l�的��L��中抽�?个来�Q�要�?个号码不能相�q�，有多��种抽法�Q��?br>
�q�问题的本意应该是两两不相连的情��c�?br>
首先定义一个函敎ͼ�F(m,p), m是确定抽出几个号码，p是��d��有几个号码，那么
F(m,p)的值域��是代表在p个连�l�号码中�Q�抽��Z��两不相连的m个号码，��d��有几�U�组合；

接着��定状态�{�U�L��E�，�l�过观察�Q�p必须满��条�gp >= m*2-1�Q�否则F��׃ؓ0�Q�同�?br>F(6,20) = F(5,18) + F(5,17) + F(5,16) + ... + F(5,9)�Q?br>
因此可以得出如下状态�{�U�L��E�，
�?p > m*2-1�Q�F(m,p) = Sigma(F(m-1,q)) + 1�Q�其中q �?m-1)*2 �?p-2�Q?br>�?p == m*2-1�Q�F(m,p) = 1�Q?br>�?p < m*2-1�Q�F(m,p) = 0�Q?br>
虽然分析到此�Q�已可以着手具体实玎ͼ�但是�q�是有些问题值得�q�一步分析，比如F(m,p)和F(m,p-1)之间存在何种关系�Q�若使用递归�Q�就当前�q�个问题效率估计会是问题�Q?br>
因此�Ҏ��方程�q�一步分析，
F(5,18) = Sigma(F(4,q)�Q? F(4,7)�Q�q�?�?6
F(5,17) = Sigma(F(4,q)�Q? F(4,7)�Q�q�?�?�Q?br>...
可进一步推出，
�?p > m*2-1, F(m,p) = F(m,p-1) + F(m-1,p-2)�Q?br>
�q�样我们��得��C��可以�q�行递推实现的�{态�{�U�L��E�；
另外�Q�对于m == 1的情形，昄��F(1,p) = p �Q?br>

#include
#include

#define MAXLEN 10000

static int F[MAXLEN];
static int R[MAXLEN];

int Compute(
   const int cM,
   const int cP)
{
  if (cM <= 0 || cP < (cM*2-1))
   return 0;
  if (cM == 1)
   return cP;
  if (cP == cM*2-1)
   return 1;

  for(int i = 0; i < MAXLEN; ++i) R[i] = i;

  for(int m = 2; m <= cM; ++m)
  {
   int floof = 2*m;
   int ceiling = cP-2*(cM-m);
   F[2*m-1] = 1;
   for(int p = floof; p <= ceiling; ++p)
   F[p] = F[p-1] + R[p-2];
   for(int j = floof; j <= ceiling; ++j)
   R[j] = F[j];
  }
  return F[cP];
}

main()
{
  Compute(6,20);
// Compute(6,19);
// Compute(5,18);
// Compute(5,17);
// Compute(4,16);
// Compute(6,13);
// Compute(6,12);

// Compute(5,11);
// Compute(5,10);
// Compute(4,9);
// Compute(4,8);
// Compute(3,7);
  return 0;
}

接着再对目前的整个实现做下复杂度分析�Q�主要处理部分基本上�׃��个��@环构成，对于R数组的初始化可作为常数项不计�Q�那�?br>
大O( F(m,p) ) = O( m*(ceiling-floor) )
   = O( m*(p-2*m) )
   �q�似于O( m*p )�Q?br>若m << p�Q�显然O(F(m,p)) = p�Q?br>若m �q�似 p, 但事实上必须p >= 2*m - 1�Q�否则F值就接近0�?�Q�因此O(F(m,p)) �q�似于const�Q?br>所以综合来看上面的�q�个实现在时间上是个�U�性复杂度的实玎ͼ�在空间上�Q��用了两个长度臛_��为p的数�l�，个�h认�ؓ可以�Ҏ��q�行�q�一步优化�?br>
对于F(6,20) = 5005

整个实现在TC++ 3.0上验证通过�?br>

flagman 2010-12-03 10:53 发表评论

久久婷婷国产综合精品青草,久久夜色精品国产亚洲aⅴ,欧美一区二区久久久

一个抽��L��问题