博客地图

注：因此flash经常更新，为保证各位看到的都是最新版，采用了无缓存技术，所以显示该页面需要一些时间，请耐心等待。
心得及更新日志：

2006年8月9日
发现将swf、js文件改名为rar后直接上传到此博客
发现可以用以下代码发布flash

< object >< embed  src ="FLASH_URL"  width ="500"  height ="680"  quality ="high"  pluginspage ="http://www.macromedia.com/go/getflashplayer"  type ="application/x-shockwave-flash"  scale ="exactfit" ></ embed ></ object >

发现flash不会每次重新下载，想到用添加随机冗余变量解决
发现此博客不支持JS，但可以引用.js文件
更新结果：成功发布flash，并使客户每次浏览时都重新下载。

namespace  UnionNS {
     /**/ /* 解决：并查集
     *算法：树状、带路径压缩的并查集
     *备注：by Cockerel 06-08-27
      */
     const   int  maxV = 100 ;
     int  p[maxV]; // p[i]= p[i]>=0 ? 父编号 : 集合规模
     // 初始化：
    inline  void  init() {
        memset(p, - 1 , sizeof (p)); // 初始化为根且规模为1
    }
     // 求根运算：
    inline  int  root( int  i) {
         int  j,r;
         for (r = i; p[r] >= 0 ; r = p[r]);
         for (; i != r; i = j)
            j = p[i],p[i] = r; // 路径压缩
         return  r;
    }
     // 判断等价
    inline  bool  equal( int  i,  int  j) {
         return  root(i) == root(j);
    }
     // 求集合规模
    inline  int  size( int  i) {
         return   - p[root(i)];
    }
     // 合并
    inline  void  merge( int  i,  int  j) {
        i = root(i); j = root(j);
         if (i == j)  return ;
         if (p[i] < p[j]) // 树状合并
            p[i] += p[j], p[j] = i;
         else
            p[j] += p[i], p[i] = j;
    }
}

　　树状合并、带路径压缩的并查集可以以最大O(logN),平均O(1)的复杂度完成合并与测试操作
　　这个是2006年11月15日更新版，相比于2006年7月8日版，有以下改进：
　　1、添加求集合规模运算
　　2、简化代码
　　3、提高运行速度
　　4、减少占用空间
      相比于2006年8月8日版，修改了一个小bug。
　　该标程经VC6.0及g++编译器编译通过。

inline bool isly(int y){//isLeapYear,测试是否闰年
 return y%400==0 || y%100 !=0 && y%4==0;
}

inline int days(int y, int m, int d){//返回日期序列化值days(0,1,1)==1;
 d+=m<=2 && isly(y) ? md[m]-1 : md[m];
 d+=365*y+y/4-y/100+y/400+1;
 return d;
}
inline int day(int y, int m, int d){//返回日期是星期几(0-日,1-一....)
 return (days(y,m,d)+5)%7;
}
//**************************
void test();
int main(){
 //初始化
 int i;
 for(i=2; i<=12;i++){
  md[i]+=md[i-1];
 }
 //测试
 int y1,m1,d1,y2,m2,d2;
 //freopen("in.txt","r",stdin);
 /*while(cin>>y1>>m1>>d1)
  cout<<days(y1,m1,d1)<<endl;
 while(cin>>y1>>m1>>d1>>y2>>m2>>d2)
  cout<<days(y2,m2,d2)-days(y1,m1,d1)<<endl;/**/
 //more test
 test();
 return 0;
}
#include<cassert>
void test(){
 assert(days(0,1,1)==1);
 assert(days(0,1,31)==31);
 assert(days(0,2,1)==32);
 assert(days(0,3,1)-days(0,2,28)==2);
 assert(days(0,12,31)-days(0,1,1)==365);
 assert(days(1,1,1)-days(0,12,31)==1);
 assert(days(1,3,1)-days(1,2,28)==1);
 assert(days(1,12,31)-days(0,12,31)==365);
 assert(days(4,12,31)-days(3,12,31)==366);
 assert(days(100,3,1)-days(100,2,28)==1);
 assert(days(101,1,1)-days(100,1,1)==365);
 assert(days(401,2,28)-days(400,2,28)==366);
 assert(days(1000,3,1)-days(1000,2,28)==1);
 assert(days(2000,3,1)-days(2000,2,28)==2);
 assert(days(2000,2,1)-days(2000,1,30)==2);
 assert(days(2100,3,1)-days(2100,2,28)==1);
 assert(days(2000,4,1)-days(2000,3,30)==2);
 assert(days(2000,5,1)-days(2000,4,30)==1);
 assert(days(2000,6,1)-days(2000,5,30)==2);
 assert(days(2000,7,1)-days(2000,6,30)==1);
 assert(days(2000,8,1)-days(2000,7,30)==2);
 assert(days(2000,9,1)-days(2000,8,30)==2);
 assert(days(2000,10,1)-days(2000,9,30)==1);
 assert(days(2000,11,1)-days(2000,10,30)==2);
 assert(days(2000,12,1)-days(2000,11,30)==1);
 assert(days(2001,1,1)-days(2000,12,30)==2);
 assert(days(3000,12,31)==1096093);
 assert(day(2006,6,14)==3);
 assert(day(2008,3,1)==6);
 assert(day(1985,10,3)==4);
 assert(day(2006,1,1)==0);//Sunday.
 cout<<"Accepted!"<<endl;

}

---
本文章使用开源内容管理kicoy发布

//#include<algorithm>
//快速排序sort()  (平均O(NlogN) 
//稳定排序stable_sort() (最好O(NlogN)，最坏O(N(logN)^2) 用法与sort()相同
//堆排序s ort_heap()  (O(NlogN)) 用法同sort()，要先make_heap()或push_heap()
/************目录************
用法一：内置类型的由小到大排序：使用默认比较函数(less<T>())
 sort(a,a+len); //a:数组名，len:数组长度=sizeof(arrray)/sizeof(*array)

用法二:内置类型的由大到小排序：使用内置比较函数(greater<T>())
 sort(a,a+len,greater<int>()); //greater<Type>():#include<functional>

用法三:自定义类型对象数组的由大到小排序：使用游离比较函数(myGreater(Type&, Type&)
 bool myGreater(const Type& a, const Type& b){ return a>b;}
 sort(a,a+len,myGreater); //自定义类型对象数组的由大到小排序
 堆排序版本：
 bool myGreater(const Type& a, const Type& b){ return a>b;}
 make_heap(a,a+len,myGreater);
 sort_heap(a,a+len,myGreater); //参数必须完全一样!
 
用法四:指针数组的由大到小排序：使用游离比较函数(myGreater(const Type*, const Type*)
 bool myGreater(const int* a, const int* b){ return *a>*b;}
 sort(p,p+len,myGreater); //指针数组的由大到小排序，适用于索引排序
/**/
//***********例子************
#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;
//用法一：内置类型的由小到大排序：使用默认比较函数(less<T>())
/*void main()
{
 int a[]={3, 1,4,2,5};
 int len=sizeof(a)/sizeof(int);
 sort(a,a+len); //默认：内置类型的由小到大排序
 for (int i=0; i<len; i++)
  cout<<a[i]<<'\t';
 cout<<endl;
}
/**/
//用法二:内置类型的由大到小排序：使用内置比较函数(greater<T>())
/*void main()
{
 int a[]={3, 1,4,2,5};
 int len=sizeof(a)/sizeof(int);
 sort(a,a+len,greater<int>()); //内置类型的由大到小排序
 for (int i=0; i<len; i++)
  cout<<a[i]<<'\t';
 cout<<endl;
}
/**/
//用法三:自定义类型对象数组的由大到小排序：使用游离比较函数(myGreater(Type&, Type&)
/*bool myGreater(int& a, int& b){ return a>b;}
void main()
{
 int a[]={3, 1,4,2,5};
 int len=sizeof(a)/sizeof(int);
 sort(a,a+len,myGreater); //自定义类型的由大到小排序
 for (int i=0; i<len; i++)
  cout<<a[i]<<'\t';
 cout<<endl;
}
/**/
//sort_heap版本：
bool myGreater(int& a, int& b){ return a>b;}
void main()
{
 int a[]={3, 1,4,2,5};
 int len=sizeof(a)/sizeof(int);
 make_heap(a,a+len,myGreater);
 sort_heap(a,a+len,myGreater); //自定义类型的由大到小排序
 for (int i=0; i<len; i++)
  cout<<a[i]<<'\t';
 cout<<endl;
}
/**/

//用法四:自定义类型指针数组的由大到小排序：使用游离比较函数(myGreater(Type&, Type&)
/*bool myGreater(int* a, int* b){ return *a>*b;}
void main()
{
 int a[]={3, 1,4,2,5};
 int* p[5];
 for(int i=0;i<5;i++) p[i]=&a[i];
 int len=sizeof(a)/sizeof(int);
 sort(p,p+len,myGreater); //自定义类型的由大到小排序
 for (i=0; i<len; i++)
  cout<<a[i]<<'\t';
 cout<<endl;
 for (i=0; i<len; i++)
  cout<<*p[i]<<'\t';
 cout<<endl;
}
/**/

---
本文章使用开源内容管理kicoy发布

附测试：

---
本文章使用开源内容管理kicoy发布