// 鏋勫緩鍫?/span>void BuildHeap(vector<int> & BinaryHeap)
{
int size = (int)BinaryHeap.size(); int i,j,k,l; for(i = size / 2 - 1;i >= 0;--i)
{ j = i; while(true) { k = 2 * j; l = k + 2; k = k + 1; if(l < size) { if(BinaryHeap[j] > min(BinaryHeap[k],BinaryHeap[l])) { if(BinaryHeap[l] > BinaryHeap[k]) { swap(BinaryHeap[j],BinaryHeap[k]); j = k;
} else { swap(BinaryHeap[j],BinaryHeap[l]); j = l; } } else break; } else if(k < size) { if(BinaryHeap[j] > BinaryHeap[k]) { swap(BinaryHeap[j],BinaryHeap[k]); j = k; } else break; } else break; } }
}// 鎻掑叆void insert(vector<int> & BinaryHeap,int x){ int size = (int)BinaryHeap.size(); int i = size + 1; BinaryHeap.resize(i); int j = i / 2 - 1; while(j >= 0 && BinaryHeap[j] > x) { BinaryHeap[i - 1] = BinaryHeap[j]; i = j + 1; j = (j + 1) / 2 - 1; } BinaryHeap[i - 1] = x;}// 鍒犻櫎鏈灝忓厓int DeleteMin(vector<int> & BinaryHeap){ int size = (int)BinaryHeap.size(); int min = BinaryHeap[0],last = BinaryHeap[size - 1]; int i,child; for(i = 0;i * 2 + 2 < size;i = child) { // find smaller child child = i * 2 + 1; if(child < size && BinaryHeap[child + 1] < BinaryHeap[child]) ++child; // percolate one level if(BinaryHeap[child] < last) BinaryHeap[i] = BinaryHeap[child]; else break; } BinaryHeap[i] = last; BinaryHeap.resize(size - 1); return min;}]]>
{
queue<int> q;
int i,j;
int size = (int)AdjacencyMatrix.size();
vector<int> inDegree(size,0);
for(i = 0;i < size;++i)
{
for(j = 0;j < size;++j)
if(AdjacencyMatrix[j][i] == 1)
++inDegree[i];
if(inDegree[i] == 0)
q.push(i);
}
int v;
while(!q.empty())
{
// output
v = q.front();
q.pop();
for(i = 0;i < size;++i)
{
if(AdjacencyMatrix[v][i] == 1)
--inDegree[i];
if(inDegree[i] == 0)
q.push(i);
}
}
if(!q.empty())
cerr << "Graph has a cycle" << endl;
}
]]>
/***************************************************************/
/* 榪斿洖鏍囧噯姝ｆ佸垎甯冪殑绱Н鍑芥暟錛岃鍒嗗竷鐨勫鉤鍧囧間負 0錛屾爣鍑嗗亸宸負 1銆?nbsp; */
/***************************************************************/
double NormSDist(const double z)
{
// this guards against overflow
if(z > 6) return 1;
if(z < -6) return 0;
static const double gamma = 0.231641900,
a1 = 0.319381530,
a2 = -0.356563782,
a3 = 1.781477973,
a4 = -1.821255978,
a5 = 1.330274429;
double k = 1.0 / (1 + fabs(z) * gamma);
double n = k * (a1 + k * (a2 + k * (a3 + k * (a4 + k * a5))));
n = 1 - Normal(z) * n;
if(z < 0)
return 1.0 - n;
return n;
}
/***************************************************************/
/* 榪斿洖鏍囧噯姝ｆ佸垎甯冪瘡縐嚱鏁扮殑閫嗗嚱鏁般傝鍒嗗竷鐨勫鉤鍧囧間負 0錛屾爣鍑嗗亸宸負 1銆?/font> */
/***************************************************************/
double normsinv(const double p)
{
static const double LOW = 0.02425;
static const double HIGH = 0.97575;
/* Coefficients in rational approximations. */
static const double a[] =
{
-3.969683028665376e+01,
2.209460984245205e+02,
-2.759285104469687e+02,
1.383577518672690e+02,
-3.066479806614716e+01,
2.506628277459239e+00
};
static const double b[] =
{
-5.447609879822406e+01,
1.615858368580409e+02,
-1.556989798598866e+02,
6.680131188771972e+01,
-1.328068155288572e+01
};
static const double c[] =
{
-7.784894002430293e-03,
-3.223964580411365e-01,
-2.400758277161838e+00,
-2.549732539343734e+00,
4.374664141464968e+00,
2.938163982698783e+00
};
static const double d[] =
{
7.784695709041462e-03,
3.224671290700398e-01,
2.445134137142996e+00,
3.754408661907416e+00
};
double q, r;
errno = 0;
if (p < 0 || p > 1)
{
errno = EDOM;
return 0.0;
}
else if (p == 0)
{
errno = ERANGE;
return -HUGE_VAL /* minus "infinity" */;
}
else if (p == 1)
{
errno = ERANGE;
return HUGE_VAL /* "infinity" */;
}
else if (p < LOW)
{
/* Rational approximation for lower region */
q = sqrt(-2*log(p));
return (((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1);
}
else if (p > HIGH)
{
/* Rational approximation for upper region */
q = sqrt(-2*log(1-p));
return -(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1);
}
else
{
/* Rational approximation for central region */
q = p - 0.5;
r = q*q;
return (((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q /
(((((b[0]*r+b[1])*r+b[2])*r+b[3])*r+b[4])*r+1);
}
}
]]>
#include < vector >
using namespace std;
// Korobov rules
vector < vector < double > > korobov( int a, // base
int n, // sample size(a prime)
int t) // dimensional
{
vector<double> G(t);
vector< vector<double> > U(n,vector<double>(t)); // t-dimensional points
int i,j;
for(i = 0;i < t;i++)
G[i] = pow(a,i) / (double)n;
for(i = 0;i < n;i++)
for (j = 0;j < t;j++)
{
U[i][j] = fmod(i * G[j],1);
}
G.clear();
return U;
}
]]>