数码果微易销18大功能

微官网：快速帮用户打造超炫微信移动网站

微易销全国首创微信3G网站，用户只要通过简单的设置，就能快速生成属于您自己的微信3G网站，并且有各种精美模板，可供选择，还有自定义模版，可以设计出自己的风格，让您的粉丝有种惊艳的感觉。

微信会员卡：微时代会员卡，方便携带，永不挂失

微信会员卡通过在微信内植入会员卡，基于全国6亿微信用户，帮助企业建立集品牌推广、会员管理、营销活动、统计报表于一体的微信会员管理平台。清晰记录企业用户的消费行为并进行数据分析；还可根据用户特征进行精细分类，从而实现各种模式的精准营销。

微活动——优惠券+刮刮卡+大转盘+微投票+一战到底的会员再营销

我们将利用微信的强交互性，让您通过对互动流程、环节和方式的设计，运用各种设计活动从而实现与用户的互动交流,，微整合系统互动符合微信娱乐性强的产品本质，微易销内置了专为商家定制的"商家营销服务模块"，包括优惠券推广模块、幸运大转盘推广模块、刮刮卡抽奖模块、微投票等功能模块，商家通过发起营销活动，对已有客户进行再营销，通过不断更新补充主题，用户可以反复参与，并可带动周边朋友一起分享，从而形成极强的口碑营销效果。

微服务——微信企业应用与电子商务

有小黄鸡陪聊加强版510万数据，过滤了广告和一些敏感词汇。 还有天气查询 ，手机查询，邮编查询，快递查询（支持160家快递公司），身份证查询，人品计算，翻译，字典，百科（全网数据），音乐80.1万 ，笑话5万条，小黄鸡陪聊510万条，诗词23万首，诗句 225万，成语5万，谜语5万，解梦3万，糗事55万，公交线路4万，火车线路4500，机器人学习功能等等......

微留言：用户的互动交流利器

"微留言"是一种能为商家带来巨大的社会化流量的功能，允许留言可以被分享于留言者的朋友圈、腾讯微博和发送给好友，这意味着留言可以被无数的粉丝分享，用户对商家进行实时且客观的评价，真实的社交环境保证了留言的客观性和有效性。"微留言"的使用商家只需做好产品和用户服务即可，随着口碑的传播，消费者将源源不断。

微相册：照片展现，让商品一览无余

微相册作为微易销平台的一项主打基本功能，为微易销用户提供图片的存储和展示服务，是基于图片兴趣分享的社区型产品。在微相册里，您可以方便的创建相册，轻松地发布您需要展示的照片，还可以拓展为商家开展活动的一种展现方式。

自定义菜单：各模块均可直接展现使用，随需求而定，随需要而链

微易销提供微信公众号自定义菜单管理功能，用户无需再通过输入关键词触发回复，直接点击菜单就可以看相关的内容，微易销可与企业原有Wap进行打通，复用企业APP原有功能，同时可定制个性化功能，帮助企业打造最便捷、易推广的微信内置APP，此功能如果结合微信3G网站可以使您的公众号用户体验更好，带给粉丝不一样的感受。

微调研：实时统计，为市场调研添加一份有力数据

微调研是一种以问卷调查的方式，基于微易销平台而展现出的一种新的在线调研应用方式，微调研已经完成调研项目数十个，涉及游戏、快速消费品、汽车、房产、美食、数码产品、家用电器等多个行业，具备有对微信用户进行生活形态研究的能力，受到行业客户的一致认可。

微房产：360度全景看房

微房产是利用微易销平台打造的一款全新超炫酷的房产官方网站，其功能非常强大，包含了楼盘介绍、子楼盘管理、户型介绍及户型图、楼盘相册、房友印象以及专家点评等功能，更有360度全景看房超强大功能震撼登场！花几分钟时间即可打造微房产官网。

微汽车：预约试驾、预约保养、360度看车、车主关怀应有尽有！

微汽车采用微易销平台进行汽车的销售管理、预约保养、预约试驾、保险计算、车贷计算、车型比较、违章查询、360度全景看车、车主关怀等功能，整个过程非常便捷，省时省力省心，并通过与微易销平台有交互能力的手机客户端，快速便捷的实现了商家的销售管理与预约过程，同时也实现了客户无需进入4s店就能进行预约保养和试驾的功能。

微喜帖：颠覆传统方式，让庆典更时尚环保

微喜帖是针对结婚庆典而推出的一款行业产品，主要是为计划结婚的用户们，通过使用微喜帖应用来向亲朋好友传播自己即将结婚的动态，可以展现用户想要表达的话、结婚日期、地址、导航、接待电话，同时亲朋好友可以在微喜帖平台上提交赴宴通知、送上祝福，并且转发喜帖。

微医疗：互联网时代的医疗小助手

用户可通过微易销平台实现在线挂号、内容设置、预约查询、预约统计的一整套服务体系，能够有效解决患者挂号难、排队累、就医不方便等一系列难题

微酒店：一键点击，轻松订房

门店管理、用户管理、房型查看、放假预订、会员卡、订餐、wifi密码获取等特殊功能。

LBS回复：LBS范围内精准的商家地理位置回复

LBS图文回复是由商家设置店铺位置，用户提交当前所在位置后，可以找到最近的商家店铺，并进行一键导航、一键拨号，如果店铺当前有进行的活动（如：优惠券、刮刮卡），也可把活动显示出来。

微餐饮——实时数据统计，监控运营效果

微易销后台可以实时统计微信公众号的粉丝关注情况和用户语音请求数，根据统计对相关推广营销活动效果及某些敏感因素对您的影响作出判断，并对相关市场行为作出相应调整，从一定程度上实现了对市场的监控与及时应对。

微商城：打造微信移动电商

"微商城"（又名Vshop）是由广州市菲拓网络科技有限公司推出的，一款基于移动互联网的商城应用服务产品，以时下最热门的互动应用微信为媒介，配合微信5.0微信支付功能，实现商家与客户的在线互动，即时推送最新商品信息给微信用户，实现微信在线的购物功能。 其主要功能包括：支持商品管理、支持会员管理、支持购物车、支持商品分类管理、支持订单管理、支持店铺设置、支持支付方式管理、支持配送方式管理。

微预约：在线预约，微易销帮您一键搞定

微预约是商家利用微易销平台实现在线预约的一种服务，可以运用于汽车、房产、酒店、医疗、餐饮等一系列行业，给用户的出行办事、购物、消费带来了极大的便利！且操作简单，响应速度非常快，受到业界的一致好评！

微生活：生活服务、方便快捷更高效

通过微生活服务，用户可以时时刻刻享受在线购物、点餐、定机票、预约酒店等多项服务的功能，彻底改变了用户传统的生活模式。

1、商户管理：微生活支持商户管理功能，其中包括商户的基础设置、商户信息设置、会员设置、优惠设置以及商品的展示功能，让用户通过微易销平台可以浏览整个商圈。

2、会员管理：用户通过在手机端领取会员卡，商家就可以在微易销后台查询到用户的会员记录，包括会员卡号、用户姓名、手机号、领取卡的时间、所属用户以及会员卡的状态设置，让用户资源随手可得。

 

第二篇：昆明理工大学人工智能八数码难题实验报告

昆明理工大学信息工程与自动化学院学生实验报告

（ 20XX — 20XX 学年 第 1 学期 ）

课程名称：人工智能 开课实验室：信自楼445

20XX年10月 25日

一、上机目的及内容

1.上机内容

用确定性推理算法求解教材65-66页介绍的八数码难题。

2.上机目的

（1）复习程序设计和数据结构课程的相关知识，实现课程间的平滑过渡；

（2）掌握并实现在小规模状态空间中进行图搜索的方法；

（3）理解并掌握图搜索的技术要点。

二、实验原理及基本技术路线图（方框原理图或程序流程图）

（1）设计并实现程序，求解出正确的解答路径；

（2）对所设计的算法采用大O符号进行时间复杂性和空间复杂性分析；

（3）对一般图搜索的技术要点和技术难点进行评述性分析。

三、所用仪器、材料（设备名称、型号、规格等或使用软件）

1台PC及VISUAL C++6.0软件

四、实验方法、步骤（或：程序代码或操作过程）

1、先创建项目，新建Source File文件：main.cpp。

#include ＜iostream＞

#include "Node.h"

#include "Queue.h"

#include "Search.h"

#include "Tree.h"

void CreateNode1(std::vector＜int＞& s)

{

s.push_back(2);

s.push_back(8);

s.push_back(3);

s.push_back(1);

s.push_back(0);

s.push_back(4);

s.push_back(7);

s.push_back(6);

s.push_back(5);

}

void CreateNode4(std::vector＜int＞& d)

{

d.push_back(2);

d.push_back(8);

d.push_back(3);

d.push_back(1);

d.push_back(6);

d.push_back(4);

d.push_back(7);

d.push_back(0);

d.push_back(5);

}

void CreateNode8(std::vector＜int＞& d)

{

d.push_back(0);

d.push_back(2);

d.push_back(3);

d.push_back(1);

d.push_back(8);

d.push_back(4);

d.push_back(7);

d.push_back(6);

d.push_back(5);

}

void CreateNode20(std::vector＜int＞& d)

{

d.push_back(2);

d.push_back(0);

d.push_back(8);

d.push_back(1);

d.push_back(4);

d.push_back(3);

d.push_back(7);

d.push_back(6);

d.push_back(5);

}

void CreateNode27(std::vector＜int＞& d)

{

d.push_back(1);

d.push_back(2);

d.push_back(3);

d.push_back(8);

d.push_back(0);

d.push_back(4);

d.push_back(7);

d.push_back(6);

d.push_back(5);

}

void CreateNode_test1(std::vector＜int＞& d)

{

d.push_back(7);

d.push_back(6);

d.push_back(5);

d.push_back(4);

d.push_back(0);

d.push_back(1);

d.push_back(3);

d.push_back(8);

d.push_back(2);

}

void test_expand()

{

std::vector＜int＞ s;

CreateNode1(s);

std::vector＜int＞ d;

CreateNode4(d);

Node source(s);

Node dest(d);

source.Display();

Search search(&source);

std::cout ＜＜ source.Expand(dest, search);

}

void test_search()

{

std::vector＜int＞ s;

CreateNode1(s);

std::vector＜int＞ d;

CreateNode4(d);

Node source(s);

Node dest(d);

source.Display();

dest.Display();

Search search(&source);

search.Find( & dest);

search.DisplayRoute();

}

void test_search2level()

{

std::vector＜int＞ s;

CreateNode1(s);

std::vector＜int＞ d;

CreateNode8(d);

Node source(s);

Node dest(d);

source.Display();

dest.Display();

Search search(&source);

search.Find( & dest);

search.DisplayRoute();

}

void test_search_lab1()

{

std::vector＜int＞ s;

CreateNode1(s);

std::vector＜int＞ d;

CreateNode27(d);

Node source(s);

Node dest(d);

source.Display();

dest.Display();

Search search(&source);

search.Find( & dest);

search.DisplayRoute();

}

int main(int argc, char** argv)

{

// test_expand();

// test_search();

// test_search2level();

// test_search_lab1();

std::vector＜int＞ s;

CreateNode1(s);

std::vector＜int＞ d;

CreateNode27(d);

Node source(s);

Node dest(d);

source.Display();

dest.Display();

Search search(&source);

search.Find( & dest);

search.DisplayRoute();

return 0;

}

2、新建Source File文件：Node.cpp

#ifndef PROGECT_1_NODE

#define PROGECT_1_NODE

#include ＜vector＞

#include "Search.h"

enum OP

{

EMPTY,

UP,

DOWN,

LEFT,

RIGHT

};

bool IsOpposite(OP opa, OP opb);

class Node

{

public:

Node(std::vector＜int＞ const& state);

bool Expand(Node const& destNode, Search& search);

void Display() const;

void DisplayRoute() const;

bool operator==(Node const& v) const;

private:

Node* CreateChild(OP op);

int FindEmptySpaceId() const;

std::vector＜OP＞ GenerateLegalOperators(int spaceId) const;

int CalIdBasedOP(OP op, int spaceId) const;

bool IsWithinRange(OP op, int spaceId) const;

std::vector＜int＞ m_state;

Node *m_pParent;

std::vector＜Node*＞ m_children;

OP m_op;

};

#endif // PROGECT_1_NODE

3新建Heard File文件：node.h。

代码：#include ＜iostream＞

#include ＜math.h＞

#include "Node.h"

bool IsOpposite(OP opa, OP opb)

{

if (LEFT==opa && RIGHT == opb)

return true;

if (RIGHT==opa && LEFT == opb)

return true;

if (UP==opa && DOWN == opb)

return true;

if (DOWN==opa && UP == opb)

return true;

return false;

}

Node::Node(std::vector＜int＞ const& state)

: m_state(state)

, m_pParent(NULL)

, m_children()

, m_op(EMPTY)

{

}

void ShowOP(OP op)

{

switch (op)

{

case EMPTY:

std::cout ＜＜ "EMPTY";

break;

case UP:

std::cout ＜＜ "UP";

break;

case DOWN:

std::cout ＜＜ "DOWN";

break;

case LEFT:

std::cout ＜＜ "LEFT";

break;

case RIGHT:

std::cout ＜＜ "RIGHT";

break;

default:

exit(-1);

}

}

void ShowOPs(std::vector＜OP＞ const& ops)

{

for (int id=0; id＜ops.size(); ++id)

{

ShowOP(ops[id]);

std::cout ＜＜ " ";

}

std::cout ＜＜ std::endl;

}

bool Node::Expand(Node const& destNode, Search& search)

{

int spaceId = FindEmptySpaceId();

std::cout ＜＜ "space is at " ＜＜ spaceId ＜＜ std::endl;

std::vector＜OP＞ legalOPs = GenerateLegalOperators(spaceId);

ShowOPs(legalOPs);

while ( legalOPs.size() ＞ 0 )

{

OP op = legalOPs[ legalOPs.size() - 1 ];

legalOPs.pop_back();

Node* pChild = CreateChild(op);

if ( *pChild == destNode )

{

search.SetDestPt(pChild);

return true;

}

search.GetQueue().EnQueue(pChild);

}

return false;

}

void Node::Display() const

{

for(int i=0; i＜m_state.size(); ++i)

{

std::cout ＜＜ m_state[i] ＜＜ " ";

}

std::cout ＜＜ std::endl;

std::cout ＜＜ " pParent: " ＜＜ m_pParent ＜＜ std::endl;

std::cout ＜＜ " op: ";

ShowOP(m_op);

std::cout ＜＜ std::endl;

std::cout ＜＜ " ";

for(int j=0; j＜m_children.size(); ++j)

{

std::cout ＜＜ m_children[j] ＜＜ " ";

}

std::cout ＜＜ std::endl;

}

void Node::DisplayRoute() const

{

std::vector＜OP＞ routeOps;

Node const* pNode = this;

while ( NULL != pNode )

{

routeOps.push_back(pNode-＞m_op);

pNode = pNode-＞m_pParent;

}

for(int id=routeOps.size()-2; id＞=0 ; --id)

{

ShowOP( routeOps[id] );

std::cout ＜＜ " ";

}

std::cout ＜＜ std::endl;

}

bool Node::operator==(Node const& v) const

{

for (int id=0; id＜m_state.size(); ++ id)

{

if ( m_state[id] != v.m_state[id] )

return false;

}

return true;

}

Node* Node::CreateChild(OP op)

{

std::vector＜int＞ childState = m_state;

int exchangePos1 = FindEmptySpaceId();

int exchangePos2 = CalIdBasedOP(op, exchangePos1);

int temp = childState[exchangePos1];

childState[exchangePos1] = childState[exchangePos2];

childState[exchangePos2] = temp;

Node* child = new Node(childState);

child-＞m_pParent = this;

child-＞m_op = op;

m_children.push_back(child);

return child;

}

int Node::FindEmptySpaceId() const

{

for (int id=0; id＜m_state.size(); ++id)

{

if ( 0 == m_state[id] )

{

return id;

}

}

return -1;

}

std::vector＜OP＞ Node::GenerateLegalOperators(int spaceId) const

{

std::vector＜OP＞ allPossibleOps;

allPossibleOps.push_back(UP);

allPossibleOps.push_back(DOWN);

allPossibleOps.push_back(LEFT);

allPossibleOps.push_back(RIGHT);

std::vector＜OP＞ ops;

for (int id=0; id＜allPossibleOps.size(); ++id)

{

OP op = allPossibleOps[id];

if( IsOpposite(op, m_op) )

{

continue;

}

if ( IsWithinRange(op, spaceId) )

{

ops.push_back(op);

}

}

return ops;

}

int Node::CalIdBasedOP(OP op, int spaceId) const

{

switch (op)

{

case UP:

spaceId -= int( sqrt( m_state.size() ) );

break;

case DOWN:

spaceId += int( sqrt( m_state.size() ) );

break;

case LEFT:

--spaceId;

break;

case RIGHT:

++spaceId;

break;

default:

return -1;

}

return spaceId;

}

bool Node::IsWithinRange(OP op, int spaceId) const

{

spaceId = CalIdBasedOP(op, spaceId);

if (spaceId ＞= 0 && spaceId ＜ m_state.size())

{

return true;

}

return false;

}

4、新建Source File文件：Queue.cpp，

代码：#include "Queue.h"

void Queue::EnQueue(Node* pNode)

{

m_queue.push_back(pNode);

}

Node* Queue::DeQueue()

{

if ( m_queue.size() == 0 )

{

return NULL;

}

Node* pNode = m_queue[0];

m_queue.pop_front();

return pNode;

}

5新建Heard File文件：Queue.h。

代码：

#ifndef PROGECT_1_QUEUE

#define PROGECT_1_QUEUE

#include ＜deque＞

class Node;

class Queue

{

public:

void EnQueue(Node* pNode);

Node* DeQueue();

private:

std::deque＜Node*＞ m_queue;

};

#endif // PROGECT_1_QUEUE

6、新建Source File文件：Search.cpp，

代码：

#include "Search.h"

#include "Node.h"

Search::Search(Node* root)

: m_queue()

, m_pDestNode( NULL )

{

m_queue.EnQueue(root);

}

Node* Search::Select()

{

return m_queue.DeQueue();

}

void Search::Find(Node* destNode)

{

bool isFound = false;

while ( !isFound )

{

Node* pNode = Select();

pNode-＞Display();

isFound = pNode-＞Expand(*destNode, *this);

}

}

void Search::DisplayRoute() const

{

m_pDestNode-＞DisplayRoute();

}

7新建Heard File文件：Search.h。

代码：

#ifndef PROGECT_1_SEARCH

#define PROGECT_1_SEARCH

#include "Queue.h"

class Node;

class Search

{

public:

Search(Node* root);

Queue& GetQueue()

{

return m_queue;

}

void Find(Node* destNode);

Node* Select();

void SetDestPt(Node* pDestNode)

{

m_pDestNode = pDestNode;

}

void DisplayRoute() const;

private:

Queue m_queue;

Node* m_pDestNode;

};

#endif // PROGECT_1_SEARCH

8、新建Source File文件：Tree.cpp，

代码：

#include "Tree.h"

9新建Heard File文件：Tree.h。

代码：

#ifndef PROGECT_1_TREE

#define PROGECT_1_TREE

#endif // PROGECT_1_TREE

五、实验过程原始记录( 测试数据、图表、计算等)

六、实验结果、分析和结论（误差分析与数据处理、成果总结等。其中，绘制曲线图时必须用计算纸或程序运行结果、改进、收获）

通过完成这次八数码难题试验报告，我对编程的理解更深刻了，以前做的很多编程仅仅是

几十行的一个函数的代码，而这次的工作量明显大了很多，需要构建几个

好多文件才能完成，在试验中虽然遇到很多的困难，但在老师同学的帮助下，还是学到了很多知识，这次的试验使我在以后的编程中，思路更加开阔了