CATIA-CATIA V5-6R2017 WIN10 64位版本安装+许可证的安装配置（CATIA启动时必须要调用许可证服务器否则启动不起来）

Posted 2023-06-07 马踏飞燕Beautiful

CATIA V5-6R2017 WIN10 64位安装步骤：

1.先使用“百度网盘客户端”下载CATIA V5-6R2017软件安装包到电脑磁盘英文路径文件夹下，并解压缩，安装前先断开电脑网络，然后双击打开CATIAV5R2017文件夹，找到setup.exe，鼠标右击选择【以管理员身份运行】

2.正在准备安装中，稍等片刻自动进入安装界面

3.点击【下一步】

4.选择软件安装路径，默认安装在C盘，点击【浏览】按钮可更改软件安装路径，但需注意：安装路径文件夹名称均不能含有中文字符！小编这里将软件安装在D盘CATIA2017文件夹下(需提前在D盘新建名为CATIA2017的文件夹)，然后点击【下一步】

5.建议不要更改安装目录，直接点击【下一步】

6.点击【是】

7.先勾选“完全安装-将安装所有文件”，然后点击【下一步】

8.默认，点击【下一步】

9.默认，点击【下一步】

10.点击【下一步】

11.默认，点击【下一步】

12.默认，点击【下一步】

13.点击【下一步】

14.点击【安装】

15.正在安装中，这个过程过程大概需要20分钟左右的时间，如果安装过程中弹出“Windows安全警报”提示，直接点击【允许访问】

16.先去掉“我希望现在启动CATIA P3 V5-6R2017”前面的勾选，暂不打开软件，然后点击【完成】

17.返回初始软件安装包文件夹，双击打开“SolidSQUAD”文件夹

18.在文件夹中找到“DSL Installer.exe”，选中后鼠标右击选择【以管理员身份运行】，注意：一定要以管理员允许，否则易破解失败

19.点击【Next】

20.默认，点击【Install】

21.正在安装中，这个过程大概需要5分钟的时间，请耐心等待安装完成

22.安装完成后会自动弹出下面的窗口，暂时不要进行任何操作，请勿关闭这个窗口

23.找到桌面上的“此电脑”图标，选中后鼠标右击选择【属性】

24.点击【高级系统设置】

25.在“计算机名”栏中找到“计算机全名”，将计算机名称全选后“Ctrl+C”复制，接着“Ctrl+V”粘贴至安装界面中“许可证服务器名称”栏后面的框中，然后点击【确定】

26.选中如下图所示选项，选中后鼠标右击选择【连接】

27.再次选中如图所示选项，选中后鼠标右击选择【显示特性】

28.打开“服务器配置”窗口，暂时不要进行任何操作，请勿关闭这个窗口

29.再次返回初始软件安装包，然后找到“DSLS.exe”选中后鼠标右击选择【以管理员身份运行】

30.将右图中的两个信息分别填入左图中，其中“名称”只能手动输入，“计算机 ID”可选中后“Ctrl+C” 复制再“Ctrl+V”粘贴填写，完成后点击【Generate】

31.先点击“桌面”，然后点击【保存】

32.点击【OK】

33.点击【确定】

34.点击一下如图所示的“第四个按钮”

35.先单击选中刚才保存在桌面上的文件，选中后点击【打开】

36.点击【确定】

37.点击【关闭】

38.点击【Finish】

39.翻出初始软件安装包，双击打开“Client”文件夹

40.双击打开“Win64”文件夹（针对64位系统）

41.选中“netapi32.dll”后，鼠标右击选择【复制】

42.找到桌面上的CATIA P3 V5-6R2017图标，选中后鼠标右击选择【打开文件所在的位置】

43.在文件夹内空白处鼠标右击选择【粘贴】

44.返回初始软件安装包，找到“ProgramData”文件夹，选中后鼠标右击选择【复制】

45.双击桌面“此电脑”图标打开资源管理器窗口，先点击窗口上方的“查看”，然后勾选“隐藏的项目”，再双击“本地磁盘C”打开C盘

46.在C盘文件夹内空白处鼠标右击选择【粘贴】，若C盘内不显示ProgramData文件夹，那么返回上一步操作

47.点击【继续】，如果不放心，再复制粘贴一次，然后点击【替换目标中的文件】

48.返回桌面，找到“CATIA P3 V5-6R2017”图标，鼠标右击选择【以管理员身份运行】

49.弹出“尚未请求配置或产品许可证”窗口，然后点击【确定】；

50.如果弹出“Window安全警报”，直接点击【允许访问】

51.拖动许可证管理器中的滚轮，勾选除了“DIC、I3D、ED2”这三个以外的所有选项，然后点击【确定】最后重新启动软件即可。

52.打开CATIA P3 V5-6R2017中文版软件，界面如下：

本站资料来源于互联网，仅供学习交流

CATIA获取：点此download

 

参考：https://zhuanlan.zhihu.com/p/552289860?utm_id=0

生活其实也很简单，喜欢的就去争取、得到的就珍惜、失去的就忘记。

leetcode 刷题录

 

11. 盛最多水的容器

class Solution {
public:
    int maxArea(vector<int>& height) {
       vector<int> & v =height;
       int l =0,r=v.size()-1;
       int res = 0;
        while(l<r)
        {
           int lval = v[l];
           int rval = v[r];
           int minval = min(lval,rval);
           res =max(res,minval*(r-l));
           if(lval<rval) l++;
           else r--; 
        }
       return res ;
    }
};

View Code

 

34. 搜索范围

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> v(2,-1);
        int high =binarySearchUp(nums,target,0,nums.size()-1);
    
        int low =binarySearchDown(nums,target,0,nums.size()-1);
        //DBG2(high,low);

        if(high >= low )
        {
            v[0]=low;
            v[1]=high;
        }
 
        return v;
    }
private:
 
    int binarySearchUp(vector<int> & nums ,int target,int begin,int end)
    {
        if(begin>end)return end;
        int mid =(begin+end) >>1;
        if(nums[mid]>target) return binarySearchUp(nums,target,begin,mid-1);
        else return binarySearchUp(nums,target,mid+1,end);    

    }   
    int binarySearchDown(vector<int> & nums  ,int target,int begin,int end)
    {
        if(begin>end)return begin;
        int mid =(begin+end) >>1;
        if(nums[mid]<target) return binarySearchDown(nums,target,mid+1,end);    
        else return binarySearchDown(nums,target,begin,mid-1);
    }
};

View Code

 

 59. 螺旋矩阵 II

 
class Solution {
public: 
    vector<vector<int> > generateMatrix(int n) {
        vector<vector<int> > v (n,vector<int> (n,0)); 
        int col_min=0,col_max=n-1,row_min=0,row_max=n-1;
        int row=-1,col=0;
        int i=1;
        while(i<=n*n)
        {
            while(++row<=row_max){ 
                v[col][row]=i++; 
         
            }
              row--; 
      
            while(++col<=col_max) {
                v[col][row]=i++; 
             
            }
              col --; row_max--;
            while(--row>=row_min) {
                v[col][row]=i++; 
                 
            }     row++;  col_max--; col_min++;
            while(--col>=col_min) {
                v[col][row]=i++;
             
            }   col++;row_min++; 
   
        } 
        return v;
    }
   
}; 

View Code

 

 60. 第k个排列

class Solution {
public:
    string getPermutation(int n, int k) {
        vector<int> v;
        for(int i=1;i<=n;i++) v.push_back(i);
        for(int i=0;i<k;i++)
        {
            next_permutation(v.begin(),v.end());  
        };
        string str ="";
        for(auto i :v)
        {
            str+=i;
        }
        return str;
        
        
    }
};

View Code

 141. 环形链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head==NULL) return false;
        ListNode * fast=head,*last=head;
        if(fast->next&& fast->next->next) fast =fast->next->next;
        else return false ;
        if(last->next)last=last->next;
        while(fast!=last)
        {
            if(fast->next&& fast->next->next) fast =fast->next->next;
            else return false ;
            if(last->next)last=last->next;
        }
        return true;
    }
};

View Code

 

155. 最小栈

class MinStack {
public: 
    /** initialize your data structure here. */
    stack<int>all;
    stack<int>minstack;
    MinStack() {
        
    }
    
    void push(int x) {
        if(all.empty())
        {
            all.push(x);
            minstack.push(x);
        }
        else 
        {
            all.push(x);
            if(minstack.top()>=x)minstack.push(x);;
        }
    }
    
    void pop() {
        if(all.top()==minstack.top()) minstack.pop();
        all.pop();
    }
    
    int top() {
        return all.top();
    }
    
    int getMin() {
     
      return   minstack.top(); 
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

View Code

 

416. Partition Equal Subset Sum

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = accumulate(nums.begin(), nums.end(), 0), target = sum >> 1;
        if (sum & 1) return false;
        vector<bool> dp(target + 1, false);
        dp[0] = true;
        for (int num : nums) {
            for (int i = target ; i >=num ; --i) {
                dp[i] = dp[i] || dp[i - num];
            }
        }
        return dp[target];
    }
};

View Code

 

374. 猜数字大小

// Forward declaration of guess API.
// @param num, your guess
// @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
int guess(int num);

class Solution {
public:
    int guessNumber(int n) {
       int l=1,r=n;
        int mid,ret;
        while(l<r)
        {
           mid = l/2+r/2;
            // mid=l+r>>1;
            ret = guess(mid);
            if(ret==0) return mid;
            else if(ret< 0 ) r=mid-1;
            else l=mid+1;
        }
        return l;
     
    }
};

View Code

 

 378. 有序矩阵中第K小的元素

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        priority_queue<int> q ;
        for(auto & v : matrix) for(auto i:v)
        {
          q.push(i);
          if(q.size()>k)q.pop();
          
        } return q.top();
    }
};

View Code

 

383. 赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
      // unordered_map<char,int> a;
        int a[256] ={0};
        for(auto i:magazine)
        {
             
            a[i]++;
        }
        for(auto i:ransomNote)
       
        {
            
            if(a[i]> 0 ) a[i]--;
            else return false;

        }
            return true;
    }
};

View Code

 

395. 至少有K个重复字符的最长子串

View Code

 

 515. 在每个树行中找最大值

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> v;
        if(root==NULL) return v;
        queue<TreeNode*> q ;
        q.push(root);
        
        while(1)
        {
            int tmp = getnum(q);
            v.push_back(tmp);
            getnxt(q) ;
            if(q.empty())break;            
        }
        return v;
    }
    void  getnxt(queue<TreeNode*>&  tmp )
    {
        queue<TreeNode*> t ;
        while(!tmp.empty())
        {
            TreeNode* i=tmp.front();
            if(i->left)
            {
                t.push(i->left);
            }
            if(i->right)
            {
                t.push(i->right);
            } 
             tmp.pop();
        }
      
        while(!t.empty()) tmp.push(t.front()),t.pop();
    }
    int getnum(queue<TreeNode*>  tmp)
    {
        int mm = -2147483648;
         while(!tmp.empty())
        {
            int  tt = tmp.front()->val; 
            mm=max(mm,tt);
            tmp.pop();
        }
        return mm;
    }
    
};

View Code

 

 

521. 最长特殊序列 Ⅰ

class Solution {
public:
    int findLUSlength(string a, string b) {
        return a==b?-1:max(a.size(),b.size());
    }
};

View Code

 

540. 有序数组中的单一元素 

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int ans =0;
        for(auto i:nums)
            ans^=i;
        return ans;
    }
};

View Code

 

 

 639. 解码方法 2

class Solution {
public:
     int ways(char c) {  
        if (c == ‘*‘)  
            return 9;  
        if (c == ‘0‘)  
            return 0;  
        return 1;  
    }  
    int ways(char i, char j) {  
        if (i == ‘*‘ && j == ‘*‘)  
            return 15;  
        if (i == ‘*‘)  
            return (j <= ‘6‘ ? 2 : 1);  
        if (j == ‘*‘) {  
            if (i == ‘1‘)  
                return 9;  
            if (i == ‘2‘)  
                return 6;  
            return 0;  
        }  
        if (i == ‘1‘ || (i == ‘2‘ && j <= ‘6‘))  
            return 1;  
        return 0;  
    }  
    int numDecodings(string s) {
        int  n =s.length();
        if(n==0||s[0]==‘0‘) return 0;
        long f2=1,f1= (long)ways(s[0]);
        long res = f1;
        long mod = (long)1e9+7;
        for(int i=1;i<n;i++)
        {
            res = ways(s[i-1],s[i])*f2 + ways(s[i])*f1;
            res%=mod;
            f2=f1;
            f1= res;
        }
        return res;
    }
};

View Code

 

 

677. 键值映射

class MapSum {
public:
    /** Initialize your data structure here. */
    map<string,int> m;
    
    MapSum() {
        
    }
    
    void insert(string key, int val) {
        m[key] =val;
       
    }
    
    int sum(string prefix) {
           int s = 0;
        for (auto one : m)
        {
            if (prefix == one.first.substr(0, prefix.length()))
                s += one.second;
        }
        return s;
    }
};

/**
 * Your MapSum object will be instantiated and called as such:
 * MapSum obj = new MapSum();
 * obj.insert(key,val);
 * int param_2 = obj.sum(prefix);
 */

View Code

 743. 网络延迟时间

#define REP(i,l,r) for(int i=l;i<=r;i++)
class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
       const int inf = (int)1e5+9;
       int n=N,k=K;
       int m[n+1][n+1];
       int dist[n+1],vis[n+1];
       REP(i,1,n) REP(j,1,n) if(i==j)m[i][j] ;else m[i][j]=inf;
       for(auto i:times)m[i[0]][i[1]]=i[2];
       REP(i,1,n) dist[i]=m[k][i],vis[i]=0;
       vis[k]=1;
        int ans =-1;
       REP(i,1,n-1)
       {
           int minx=inf,u=k;
           REP(j,1,n) if(!vis[j] && dist[j]!=inf &&dist[j]<minx) minx=dist[j],u=j;
           if(minx==inf) return -1;
           vis[u]=1;
           ans=max(ans,minx);
           REP(j,1,n) if(!vis[j]&& dist[j]>dist[u]+m[u][j])
               dist[j]=dist[u]+m[u][j];
        
        }
        return ans;
    }
};

View Code